[INFO] cloning repository https://github.com/OriolVO/Atlas
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/OriolVO/Atlas" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FOriolVO%2FAtlas", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FOriolVO%2FAtlas'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 3c5e8ae6309ae5495f45327ce8a4750f72c092c6
[INFO] fixing OriolVO/Atlas against try#622891a4e29178280638a6b63a8908bde2c0c854+cargoflags=-Zfix-edition=end=2015,2024 for pr-157817-2
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FOriolVO%2FAtlas" "/workspace/builds/worker-7-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-7-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/OriolVO/Atlas
[INFO] finished tweaking git repo https://github.com/OriolVO/Atlas
[INFO] tweaked toml for git repo https://github.com/OriolVO/Atlas written to /workspace/builds/worker-7-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/OriolVO/Atlas on toolchain 622891a4e29178280638a6b63a8908bde2c0c854
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/OriolVO/Atlas already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:3a6becf2bc8dde7f3fa57ede90e4f284e72d296796fc446bbb1e2c7cc0530151" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] def61b1433e341a7211dbe7bf0a20537bc57c529e2d3019f9b6bfedb7a602444
[INFO] running `Command { std: "docker" "start" "def61b1433e341a7211dbe7bf0a20537bc57c529e2d3019f9b6bfedb7a602444", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-w" "/opt/rustwide/workdir" "--user" "0:0" "def61b1433e341a7211dbe7bf0a20537bc57c529e2d3019f9b6bfedb7a602444" "/opt/rustwide/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "def61b1433e341a7211dbe7bf0a20537bc57c529e2d3019f9b6bfedb7a602444", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "exec" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=" "-e" "RUSTDOCFLAGS=" "-w" "/opt/rustwide/workdir" "--user" "0:0" "def61b1433e341a7211dbe7bf0a20537bc57c529e2d3019f9b6bfedb7a602444" "/opt/rustwide/cargo-home/bin/cargo" "+622891a4e29178280638a6b63a8908bde2c0c854" "fix" "--allow-no-vcs" "--allow-dirty" "--frozen" "--all" "--all-targets" "--message-format=json" "-Zfix-edition=end=2015,2024", kill_on_drop: false }`
[INFO] [stderr] crater-edition-check: migrating to next edition
[INFO] [stderr]    Migrating compiler/Cargo.toml from 2021 edition to 2024
[INFO] [stderr]    Compiling rustix v1.1.4
[INFO] [stderr]    Compiling object v0.37.3
[INFO] [stderr]     Checking memchr v2.8.1
[INFO] [stderr]     Checking gimli v0.32.3
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]    Compiling regex-syntax v0.8.10
[INFO] [stderr]    Compiling owo-colors v4.3.0
[INFO] [stderr]     Checking is_ci v1.2.0
[INFO] [stderr]    Compiling syn v2.0.117
[INFO] [stderr]     Checking bitflags v2.12.1
[INFO] [stderr]    Compiling typeid v1.0.3
[INFO] [stderr]     Checking unicode-linebreak v0.1.5
[INFO] [stderr]     Checking supports-unicode v3.0.0
[INFO] [stderr]     Checking supports-hyperlinks v3.2.0
[INFO] [stderr]     Checking unicode-ident v1.0.24
[INFO] [stderr]     Checking console v0.16.3
[INFO] [stderr]     Checking supports-color v3.0.2
[INFO] [stderr]     Checking similar v2.7.0
[INFO] [stderr]     Checking textwrap v0.16.2
[INFO] [stderr]     Checking addr2line v0.25.1
[INFO] [stderr]    Compiling logos-codegen v0.14.4
[INFO] [stderr]     Checking terminal_size v0.4.4
[INFO] [stderr]     Checking tempfile v3.27.0
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]    Compiling clap_derive v4.6.1
[INFO] [stderr]    Compiling miette-derive v7.6.0
[INFO] [stderr]    Compiling thiserror-impl v1.0.69
[INFO] [stderr]     Checking backtrace v0.3.76
[INFO] [stderr]    Compiling logos-derive v0.14.4
[INFO] [stderr]     Checking backtrace-ext v0.2.1
[INFO] [stderr]     Checking thiserror v1.0.69
[INFO] [stderr]     Checking miette v7.6.0
[INFO] [stderr]     Checking logos v0.14.4
[INFO] [stderr]     Checking clap v4.6.1
[INFO] [stderr]     Checking serde v1.0.228
[INFO] [stderr]     Checking ron v0.12.1
[INFO] [stderr]     Checking atlas v0.1.0 (/opt/rustwide/workdir/compiler)
[INFO] [stderr]    Migrating compiler/src/lib.rs from 2021 edition to 2024
[INFO] [stderr]     Checking insta v1.47.2
[INFO] [stderr] error: errors present after applying fixes to crate `atlas`
[INFO] [stderr]  --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs
[INFO] [stderr]  ::: compiler/src/lexer.rs
[INFO] [stderr]  ::: compiler/src/parser/parse.rs
[INFO] [stderr]  ::: compiler/src/resolver.rs
[INFO] [stderr]   = cause: error: expected one of `(`, `,`, `::`, or `=`, found `+`
[INFO] [stderr]              --> compiler/src/lexer.rs:17:16
[INFO] [stderr]               |
[INFO] [stderr]            17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stderr]               |                ^ expected one of `(`, `,`, `::`, or `=`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `logos` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:18:3
[INFO] [stderr]               |
[INFO] [stderr]            18 | #[logos(skip r"[ \t\n\r]+")]
[INFO] [stderr]               |   ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]               = note: `logos` is in scope, but it is a crate, not an attribute
[INFO] [stderr]            help: `logos` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `logos` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:19:3
[INFO] [stderr]               |
[INFO] [stderr]            19 | #[logos(skip r"//[^\n]*")]
[INFO] [stderr]               |   ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]               = note: `logos` is in scope, but it is a crate, not an attribute
[INFO] [stderr]            help: `logos` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:21:7
[INFO] [stderr]               |
[INFO] [stderr]            21 |     #[regex("[0-9]+[a-zA-Z0-9]*", parse_int)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:24:7
[INFO] [stderr]               |
[INFO] [stderr]            24 |     #[regex("[0-9]+\\.[0-9]+", |lex| lex.slice().parse::<f64>().ok())]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:27:7
[INFO] [stderr]               |
[INFO] [stderr]            27 |     #[token("true", |_| true)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:28:7
[INFO] [stderr]               |
[INFO] [stderr]            28 |     #[token("false", |_| false)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:31:7
[INFO] [stderr]               |
[INFO] [stderr]            31 |     #[regex("'([^'\\\\]|\\\\.)*'", parse_char)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:34:7
[INFO] [stderr]               |
[INFO] [stderr]            34 |     #[regex("\"([^\"\\n\\\\]|\\\\.)*\"", parse_string)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:38:7
[INFO] [stderr]               |
[INFO] [stderr]            38 |     #[token("var")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:40:7
[INFO] [stderr]               |
[INFO] [stderr]            40 |     #[token("const")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:42:7
[INFO] [stderr]               |
[INFO] [stderr]            42 |     #[token("fn")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:44:7
[INFO] [stderr]               |
[INFO] [stderr]            44 |     #[token("struct")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:46:7
[INFO] [stderr]               |
[INFO] [stderr]            46 |     #[token("class")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:48:7
[INFO] [stderr]               |
[INFO] [stderr]            48 |     #[token("enum")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:50:7
[INFO] [stderr]               |
[INFO] [stderr]            50 |     #[token("choice")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:52:7
[INFO] [stderr]               |
[INFO] [stderr]            52 |     #[token("match")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:54:7
[INFO] [stderr]               |
[INFO] [stderr]            54 |     #[token("if")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:56:7
[INFO] [stderr]               |
[INFO] [stderr]            56 |     #[token("else")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:58:7
[INFO] [stderr]               |
[INFO] [stderr]            58 |     #[token("while")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:60:7
[INFO] [stderr]               |
[INFO] [stderr]            60 |     #[token("break")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:62:7
[INFO] [stderr]               |
[INFO] [stderr]            62 |     #[token("continue")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:64:7
[INFO] [stderr]               |
[INFO] [stderr]            64 |     #[token("return")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:66:7
[INFO] [stderr]               |
[INFO] [stderr]            66 |     #[token("import")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:68:7
[INFO] [stderr]               |
[INFO] [stderr]            68 |     #[token("export")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:70:7
[INFO] [stderr]               |
[INFO] [stderr]            70 |     #[token("public")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:72:7
[INFO] [stderr]               |
[INFO] [stderr]            72 |     #[token("private")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:74:7
[INFO] [stderr]               |
[INFO] [stderr]            74 |     #[token("where")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:76:7
[INFO] [stderr]               |
[INFO] [stderr]            76 |     #[token("as")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:78:7
[INFO] [stderr]               |
[INFO] [stderr]            78 |     #[token("and")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:80:7
[INFO] [stderr]               |
[INFO] [stderr]            80 |     #[token("or")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:82:7
[INFO] [stderr]               |
[INFO] [stderr]            82 |     #[token("not")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:84:7
[INFO] [stderr]               |
[INFO] [stderr]            84 |     #[token("extern")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:86:7
[INFO] [stderr]               |
[INFO] [stderr]            86 |     #[token("self")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:88:7
[INFO] [stderr]               |
[INFO] [stderr]            88 |     #[token("null")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:92:7
[INFO] [stderr]               |
[INFO] [stderr]            92 |     #[token("int")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:94:7
[INFO] [stderr]               |
[INFO] [stderr]            94 |     #[token("uint")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:96:7
[INFO] [stderr]               |
[INFO] [stderr]            96 |     #[token("int8")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:98:7
[INFO] [stderr]               |
[INFO] [stderr]            98 |     #[token("int16")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:100:7
[INFO] [stderr]                |
[INFO] [stderr]            100 |     #[token("int32")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:102:7
[INFO] [stderr]                |
[INFO] [stderr]            102 |     #[token("int64")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:104:7
[INFO] [stderr]                |
[INFO] [stderr]            104 |     #[token("uint8")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:106:7
[INFO] [stderr]                |
[INFO] [stderr]            106 |     #[token("uint16")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:108:7
[INFO] [stderr]                |
[INFO] [stderr]            108 |     #[token("uint32")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:110:7
[INFO] [stderr]                |
[INFO] [stderr]            110 |     #[token("uint64")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:112:7
[INFO] [stderr]                |
[INFO] [stderr]            112 |     #[token("float")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:114:7
[INFO] [stderr]                |
[INFO] [stderr]            114 |     #[token("float32")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:116:7
[INFO] [stderr]                |
[INFO] [stderr]            116 |     #[token("float64")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:118:7
[INFO] [stderr]                |
[INFO] [stderr]            118 |     #[token("bool")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:120:7
[INFO] [stderr]                |
[INFO] [stderr]            120 |     #[token("char")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:124:7
[INFO] [stderr]                |
[INFO] [stderr]            124 |     #[token("+")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:126:7
[INFO] [stderr]                |
[INFO] [stderr]            126 |     #[token("-")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:128:7
[INFO] [stderr]                |
[INFO] [stderr]            128 |     #[token("*")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:130:7
[INFO] [stderr]                |
[INFO] [stderr]            130 |     #[token("/")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:132:7
[INFO] [stderr]                |
[INFO] [stderr]            132 |     #[token("%")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:134:7
[INFO] [stderr]                |
[INFO] [stderr]            134 |     #[token("==")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:136:7
[INFO] [stderr]                |
[INFO] [stderr]            136 |     #[token("!=")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:138:7
[INFO] [stderr]                |
[INFO] [stderr]            138 |     #[token("<=")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:140:7
[INFO] [stderr]                |
[INFO] [stderr]            140 |     #[token(">=")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:142:7
[INFO] [stderr]                |
[INFO] [stderr]            142 |     #[token("<")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:144:7
[INFO] [stderr]                |
[INFO] [stderr]            144 |     #[token(">")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:146:7
[INFO] [stderr]                |
[INFO] [stderr]            146 |     #[token("=")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:148:7
[INFO] [stderr]                |
[INFO] [stderr]            148 |     #[token("!")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:150:7
[INFO] [stderr]                |
[INFO] [stderr]            150 |     #[token("&&")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:152:7
[INFO] [stderr]                |
[INFO] [stderr]            152 |     #[token("||")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:154:7
[INFO] [stderr]                |
[INFO] [stderr]            154 |     #[token("@")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:156:7
[INFO] [stderr]                |
[INFO] [stderr]            156 |     #[token("?")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:158:7
[INFO] [stderr]                |
[INFO] [stderr]            158 |     #[token("::")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:160:7
[INFO] [stderr]                |
[INFO] [stderr]            160 |     #[token(":")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:162:7
[INFO] [stderr]                |
[INFO] [stderr]            162 |     #[token(";")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:164:7
[INFO] [stderr]                |
[INFO] [stderr]            164 |     #[token(",")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:166:7
[INFO] [stderr]                |
[INFO] [stderr]            166 |     #[token("...")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:168:7
[INFO] [stderr]                |
[INFO] [stderr]            168 |     #[token(".")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:170:7
[INFO] [stderr]                |
[INFO] [stderr]            170 |     #[token("=>")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:172:7
[INFO] [stderr]                |
[INFO] [stderr]            172 |     #[token("(")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:174:7
[INFO] [stderr]                |
[INFO] [stderr]            174 |     #[token(")")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:176:7
[INFO] [stderr]                |
[INFO] [stderr]            176 |     #[token("{")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:178:7
[INFO] [stderr]                |
[INFO] [stderr]            178 |     #[token("}")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:180:7
[INFO] [stderr]                |
[INFO] [stderr]            180 |     #[token("[")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:182:7
[INFO] [stderr]                |
[INFO] [stderr]            182 |     #[token("]")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:185:7
[INFO] [stderr]                |
[INFO] [stderr]            185 |     #[regex("[a-zA-Z_][a-zA-Z0-9_]*", |lex| lex.slice().to_string())]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:188:7
[INFO] [stderr]                |
[INFO] [stderr]            188 |     #[token("/*", block_comment)]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:194:24
[INFO] [stderr]                |
[INFO] [stderr]            194 | fn parse_int(lex: &mut logos::Lexer<Token>) -> Option<(i64, Option<IntSuffix>)> {
[INFO] [stderr]                |                        ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required by a bound in `logos::Lexer`
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:34
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                |                                  ^^^^^^^^^^^^^^ required by this bound in `Lexer`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:227:25
[INFO] [stderr]                |
[INFO] [stderr]            227 | fn parse_char(lex: &mut logos::Lexer<Token>) -> Option<char> {
[INFO] [stderr]                |                         ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required by a bound in `logos::Lexer`
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:34
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                |                                  ^^^^^^^^^^^^^^ required by this bound in `Lexer`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:254:27
[INFO] [stderr]                |
[INFO] [stderr]            254 | fn parse_string(lex: &mut logos::Lexer<Token>) -> Option<String> {
[INFO] [stderr]                |                           ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required by a bound in `logos::Lexer`
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:34
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                |                                  ^^^^^^^^^^^^^^ required by this bound in `Lexer`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:277:28
[INFO] [stderr]                |
[INFO] [stderr]            277 | fn block_comment(lex: &mut logos::Lexer<Token>) -> logos::Filter<Token> {
[INFO] [stderr]                |                            ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required by a bound in `logos::Lexer`
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:34
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                |                                  ^^^^^^^^^^^^^^ required by this bound in `Lexer`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:338:1
[INFO] [stderr]                |
[INFO] [stderr]            338 | pub struct Lexer<'src> {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]              --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:14:5
[INFO] [stderr]               |
[INFO] [stderr]            14 |     source: &'source Token::Source,
[INFO] [stderr]               |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]               |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:343:12
[INFO] [stderr]                |
[INFO] [stderr]            343 | impl<'src> Lexer<'src> {
[INFO] [stderr]                |            ^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:344:38
[INFO] [stderr]                |
[INFO] [stderr]            344 |     pub fn new(source: &'src str) -> Self {
[INFO] [stderr]                |                                      ^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:351:25
[INFO] [stderr]                |
[INFO] [stderr]            351 |     pub fn tokenize(mut self) -> (Vec<Spanned<Token>>, Vec<AtlasError>) {
[INFO] [stderr]                |                         ^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `slice` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:195:21
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            195 |     let slice = lex.slice();
[INFO] [stderr]                |                     ^^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `slice` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:228:17
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            228 |     let s = lex.slice();
[INFO] [stderr]                |                 ^^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `slice` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:255:17
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            255 |     let s = lex.slice();
[INFO] [stderr]                |                 ^^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `remainder` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:279:25
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            279 |     let remainder = lex.remainder();
[INFO] [stderr]                |                         ^^^^^^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `bump` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:304:13
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            304 |         lex.bump(end_idx);
[INFO] [stderr]                |             ^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `bump` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:307:13
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            307 |         lex.bump(remainder.len());
[INFO] [stderr]                |             ^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:345:9
[INFO] [stderr]                |
[INFO] [stderr]            345 |         Self {
[INFO] [stderr]                |         ^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: no variant, associated function, or constant named `lexer` found for enum `Token` in the current scope
[INFO] [stderr]               --> compiler/src/lexer.rs:347:27
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- variant, associated function, or constant `lexer` not found for this enum
[INFO] [stderr]            ...
[INFO] [stderr]            347 |             inner: Token::lexer(source),
[INFO] [stderr]                |                           ^^^^^ variant, associated function, or constant not found in `Token`
[INFO] [stderr]                |
[INFO] [stderr]                = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stderr]                = note: the following trait defines an item `lexer`, perhaps you need to implement it:
[INFO] [stderr]                        candidate #1: `Logos`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied in `lexer::Lexer<'src>`
[INFO] [stderr]               --> compiler/src/lexer.rs:345:9
[INFO] [stderr]                |
[INFO] [stderr]            345 | /         Self {
[INFO] [stderr]            346 | |             source,
[INFO] [stderr]            347 | |             inner: Token::lexer(source),
[INFO] [stderr]            348 | |         }
[INFO] [stderr]                | |_________^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: within `lexer::Lexer<'src>`, the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required because it appears within the type `lexer::Lexer<'src>`
[INFO] [stderr]               --> compiler/src/lexer.rs:338:12
[INFO] [stderr]                |
[INFO] [stderr]            338 | pub struct Lexer<'src> {
[INFO] [stderr]                |            ^^^^^
[INFO] [stderr]                = note: structs must have a statically known size to be initialized
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied in `lexer::Lexer<'src>`
[INFO] [stderr]               --> compiler/src/lexer.rs:351:25
[INFO] [stderr]                |
[INFO] [stderr]            351 |     pub fn tokenize(mut self) -> (Vec<Spanned<Token>>, Vec<AtlasError>) {
[INFO] [stderr]                |                         ^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: within `lexer::Lexer<'src>`, the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required because it appears within the type `lexer::Lexer<'src>`
[INFO] [stderr]               --> compiler/src/lexer.rs:338:12
[INFO] [stderr]                |
[INFO] [stderr]            338 | pub struct Lexer<'src> {
[INFO] [stderr]                |            ^^^^^
[INFO] [stderr]                = help: unsized fn params are gated as an unstable feature
[INFO] [stderr]            help: function arguments must have a statically known size, borrowed types always have a known size
[INFO] [stderr]                |
[INFO] [stderr]            351 |     pub fn tokenize(mut &self) -> (Vec<Spanned<Token>>, Vec<AtlasError>) {
[INFO] [stderr]                |                         +
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `next` exists for struct `logos::Lexer<'src, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:357:42
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            357 |         while let Some(res) = self.inner.next() {
[INFO] [stderr]                |                                          ^^^^ method cannot be called on `logos::Lexer<'src, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]               ::: /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:1
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                | ------------------------------------------------ doesn't satisfy `logos::Lexer<'src, Token>: Iterator`
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]                        which is required by `logos::Lexer<'src, Token>: Iterator`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `span` exists for struct `logos::Lexer<'src, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:358:46
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            358 |             let span = Span::from(self.inner.span());
[INFO] [stderr]                |                                              ^^^^ method cannot be called on `logos::Lexer<'src, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `span` exists for struct `logos::Lexer<'src, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:371:44
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            371 |                     let range = self.inner.span();
[INFO] [stderr]                |                                            ^^^^ method cannot be called on `logos::Lexer<'src, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: can't compare `Token` with `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:361:30
[INFO] [stderr]                |
[INFO] [stderr]            361 |                     if token == Token::UnterminatedBlockComment {
[INFO] [stderr]                |                              ^^ no implementation for `Token == Token`
[INFO] [stderr]                |
[INFO] [stderr]                = help: the trait `PartialEq` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]              --> compiler/src/parser/parse.rs:26:27
[INFO] [stderr]               |
[INFO] [stderr]            26 |         while self.peek() != &Token::Eof {
[INFO] [stderr]               |               ----------- ^^ ----------- &Token
[INFO] [stderr]               |               |
[INFO] [stderr]               |               &Token
[INFO] [stderr]               |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(PartialEq)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]              --> compiler/src/parser/parse.rs:41:42
[INFO] [stderr]               |
[INFO] [stderr]            41 |         let is_exported = if self.peek() == &Token::Export {
[INFO] [stderr]               |                              ----------- ^^ -------------- &Token
[INFO] [stderr]               |                              |
[INFO] [stderr]               |                              &Token
[INFO] [stderr]               |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(PartialEq)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]              --> compiler/src/parser/parse.rs:80:120
[INFO] [stderr]               |
[INFO] [stderr]            80 |                     message: format!("expected top-level item (e.g. fn, struct, class, import, extern), found '{:?}'", token),
[INFO] [stderr]               |                                                                                                                ----    ^^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]               |                                                                                                                |
[INFO] [stderr]               |                                                                                                                required by this formatting parameter
[INFO] [stderr]               |
[INFO] [stderr]               = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]               = note: required for `&Token` to implement `Debug`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Debug)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]              --> compiler/src/parser/parse.rs:97:88
[INFO] [stderr]               |
[INFO] [stderr]            97 |                     message: format!("expected ABI string (e.g. \"C\"), found '{:?}'", t),
[INFO] [stderr]               |                                                                                ----    ^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]               |                                                                                |
[INFO] [stderr]               |                                                                                required by this formatting parameter
[INFO] [stderr]               |
[INFO] [stderr]               = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Debug)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:119:37
[INFO] [stderr]                |
[INFO] [stderr]            119 |         let ret_ty = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                         ----------- ^^ ------------- &Token
[INFO] [stderr]                |                         |
[INFO] [stderr]                |                         &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:142:24
[INFO] [stderr]                |
[INFO] [stderr]            142 |         if self.peek() == &Token::RParen {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:146:24
[INFO] [stderr]                |
[INFO] [stderr]            146 |         if self.peek() == &Token::Ellipsis {
[INFO] [stderr]                |            ----------- ^^ ---------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:154:28
[INFO] [stderr]                |
[INFO] [stderr]            154 |             if self.peek() != &Token::Comma {
[INFO] [stderr]                |                ----------- ^^ ------------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:159:28
[INFO] [stderr]                |
[INFO] [stderr]            159 |             if self.peek() == &Token::Ellipsis {
[INFO] [stderr]                |                ----------- ^^ ---------------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:174:27
[INFO] [stderr]                |
[INFO] [stderr]            174 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |               ----------- ^^ -------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:174:60
[INFO] [stderr]                |
[INFO] [stderr]            174 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                |
[INFO] [stderr]                |                                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:195:24
[INFO] [stderr]                |
[INFO] [stderr]            195 |         if self.peek() != &Token::RBrace {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:199:32
[INFO] [stderr]                |
[INFO] [stderr]            199 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:216:24
[INFO] [stderr]                |
[INFO] [stderr]            216 |         if self.peek() == &Token::Lt {
[INFO] [stderr]                |            ----------- ^^ ---------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:221:32
[INFO] [stderr]                |
[INFO] [stderr]            221 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:231:24
[INFO] [stderr]                |
[INFO] [stderr]            231 |         if self.peek() != &Token::RBrace {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:236:32
[INFO] [stderr]                |
[INFO] [stderr]            236 |                 if self.peek() == &Token::LParen {
[INFO] [stderr]                |                    ----------- ^^ -------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:248:32
[INFO] [stderr]                |
[INFO] [stderr]            248 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:270:27
[INFO] [stderr]                |
[INFO] [stderr]            270 |         while self.peek() == &Token::Dot {
[INFO] [stderr]                |               ----------- ^^ ----------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:285:24
[INFO] [stderr]                |
[INFO] [stderr]            285 |         if self.peek() == &Token::Lt {
[INFO] [stderr]                |            ----------- ^^ ---------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:290:32
[INFO] [stderr]                |
[INFO] [stderr]            290 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:300:27
[INFO] [stderr]                |
[INFO] [stderr]            300 |         while self.peek() == &Token::Where {
[INFO] [stderr]                |               ----------- ^^ ------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:314:27
[INFO] [stderr]                |
[INFO] [stderr]            314 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |               ----------- ^^ -------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:314:60
[INFO] [stderr]                |
[INFO] [stderr]            314 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                |
[INFO] [stderr]                |                                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:315:45
[INFO] [stderr]                |
[INFO] [stderr]            315 |             let visibility = if self.peek() == &Token::Public {
[INFO] [stderr]                |                                 ----------- ^^ -------------- &Token
[INFO] [stderr]                |                                 |
[INFO] [stderr]                |                                 &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:318:35
[INFO] [stderr]                |
[INFO] [stderr]            318 |             } else if self.peek() == &Token::Private {
[INFO] [stderr]                |                       ----------- ^^ --------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:325:28
[INFO] [stderr]                |
[INFO] [stderr]            325 |             if self.peek() == &Token::Fn {
[INFO] [stderr]                |                ----------- ^^ ---------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:329:35
[INFO] [stderr]                |
[INFO] [stderr]            329 |             } else if self.peek() == &Token::Struct {
[INFO] [stderr]                |                       ----------- ^^ -------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:334:47
[INFO] [stderr]                |
[INFO] [stderr]            334 |                 let is_const = if self.peek() == &Token::Const {
[INFO] [stderr]                |                                   ----------- ^^ ------------- &Token
[INFO] [stderr]                |                                   |
[INFO] [stderr]                |                                   &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:374:27
[INFO] [stderr]                |
[INFO] [stderr]            374 |         while self.peek() != &Token::RParen && self.peek() != &Token::Eof {
[INFO] [stderr]                |               ----------- ^^ -------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:374:60
[INFO] [stderr]                |
[INFO] [stderr]            374 |         while self.peek() != &Token::RParen && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                |
[INFO] [stderr]                |                                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:396:37
[INFO] [stderr]                |
[INFO] [stderr]            396 |         let ret_ty = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                         ----------- ^^ ------------- &Token
[INFO] [stderr]                |                         |
[INFO] [stderr]                |                         &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:442:36
[INFO] [stderr]                |
[INFO] [stderr]            442 |                     if self.peek() == &Token::RBracket {
[INFO] [stderr]                |                        ----------- ^^ ---------------- &Token
[INFO] [stderr]                |                        |
[INFO] [stderr]                |                        &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:445:40
[INFO] [stderr]                |
[INFO] [stderr]            445 |                         if self.peek() == &Token::Assign {
[INFO] [stderr]                |                            ----------- ^^ -------------- &Token
[INFO] [stderr]                |                            |
[INFO] [stderr]                |                            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:466:24
[INFO] [stderr]                |
[INFO] [stderr]            466 |         if self.peek() == &Token::Lt {
[INFO] [stderr]                |            ----------- ^^ ---------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:471:32
[INFO] [stderr]                |
[INFO] [stderr]            471 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:483:37
[INFO] [stderr]                |
[INFO] [stderr]            483 |         let ret_ty = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                         ----------- ^^ ------------- &Token
[INFO] [stderr]                |                         |
[INFO] [stderr]                |                         &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:492:27
[INFO] [stderr]                |
[INFO] [stderr]            492 |         while self.peek() == &Token::Where {
[INFO] [stderr]                |               ----------- ^^ ------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:513:24
[INFO] [stderr]                |
[INFO] [stderr]            513 |         if self.peek() == &Token::RParen {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:518:28
[INFO] [stderr]                |
[INFO] [stderr]            518 |             if self.peek() == &Token::Comma {
[INFO] [stderr]                |                ----------- ^^ ------------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:528:35
[INFO] [stderr]                |
[INFO] [stderr]            528 |         let name = if self.peek() == &Token::SelfToken {
[INFO] [stderr]                |                       ----------- ^^ ----------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:535:44
[INFO] [stderr]                |
[INFO] [stderr]            535 |         if name.0 == "self" && self.peek() != &Token::Colon {
[INFO] [stderr]                |                                ----------- ^^ ------------- &Token
[INFO] [stderr]                |                                |
[INFO] [stderr]                |                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:550:24
[INFO] [stderr]                |
[INFO] [stderr]            550 |         if self.peek() == &Token::LBracket && self.peek_nth(1) == &Token::RBracket {
[INFO] [stderr]                |            ----------- ^^ ---------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:550:64
[INFO] [stderr]                |
[INFO] [stderr]            550 |         if self.peek() == &Token::LBracket && self.peek_nth(1) == &Token::RBracket {
[INFO] [stderr]                |                                               ---------------- ^^ ---------------- &Token
[INFO] [stderr]                |                                               |
[INFO] [stderr]                |                                               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:564:39
[INFO] [stderr]                |
[INFO] [stderr]            564 |         let mut base = if self.peek() == &Token::At {
[INFO] [stderr]                |                           ----------- ^^ ---------- &Token
[INFO] [stderr]                |                           |
[INFO] [stderr]                |                           &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:569:28
[INFO] [stderr]                |
[INFO] [stderr]            569 |             if self.peek() == &Token::Question {
[INFO] [stderr]                |                ----------- ^^ ---------------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:597:42
[INFO] [stderr]                |
[INFO] [stderr]            597 |                     t => format!("{:?}", t).to_lowercase(),
[INFO] [stderr]                |                                   ----   ^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                |                                   |
[INFO] [stderr]                |                                   required by this formatting parameter
[INFO] [stderr]                |
[INFO] [stderr]                = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Debug)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:599:35
[INFO] [stderr]                |
[INFO] [stderr]            599 |                 while self.peek() == &Token::ColonColon {
[INFO] [stderr]                |                       ----------- ^^ ------------------ &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:605:32
[INFO] [stderr]                |
[INFO] [stderr]            605 |                 if self.peek() == &Token::Lt {
[INFO] [stderr]                |                    ----------- ^^ ---------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stdout] warning: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
[INFO] [stdout]    --> compiler/src/parser/parse.rs:690:34
[INFO] [stdout]     |
[INFO] [stdout] 690 |         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout]     |                                  ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/parser/parse.rs:690:16
[INFO] [stdout]     |
[INFO] [stdout] 690 |         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
[INFO] [stdout]     = warning: this changes meaning in Rust 2024
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
[INFO] [stdout]     = note: `--force-warn rust-2024-incompatible-pat` implied by `--force-warn rust-2024-compatibility`
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 690 -         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout] 690 +         if let Token::Identifier(name) = self.peek() {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stdout] warning: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
[INFO] [stdout]    --> compiler/src/resolver.rs:319:29
[INFO] [stdout]     |
[INFO] [stdout] 319 |             TypeExpr::Named(ref mut name) => {
[INFO] [stdout]     |                             ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/resolver.rs:319:13
[INFO] [stdout]     |
[INFO] [stdout] 319 |             TypeExpr::Named(ref mut name) => {
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
[INFO] [stdout]     = warning: this changes meaning in Rust 2024
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 319 -             TypeExpr::Named(ref mut name) => {
[INFO] [stdout] 319 +             TypeExpr::Named(name) => {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stdout] warning: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
[INFO] [stdout]    --> compiler/src/resolver.rs:696:29
[INFO] [stdout]     |
[INFO] [stdout] 696 |                 if let Some(ref mut v) = val {
[INFO] [stdout]     |                             ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/resolver.rs:696:24
[INFO] [stdout]     |
[INFO] [stdout] 696 |                 if let Some(ref mut v) = val {
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
[INFO] [stdout]     = warning: this changes meaning in Rust 2024
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 696 -                 if let Some(ref mut v) = val {
[INFO] [stdout] 696 +                 if let Some(v) = val {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                |
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, String, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: `--force-warn impl-trait-overcaptures` implied by `--force-warn rust-2024-compatibility`
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, f64, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, bool, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                |
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, String, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]            
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, bool, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:611:40
[INFO] [stderr]                |
[INFO] [stderr]            611 |                         if self.peek() == &Token::Comma {
[INFO] [stderr]                |                            ----------- ^^ ------------- &Token
[INFO] [stderr]                |                            |
[INFO] [stderr]                |                            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:634:74
[INFO] [stderr]                |
[INFO] [stderr]            634 |                     message: format!("expected type name, found '{:?}'", next),
[INFO] [stderr]                |                                                                  ----    ^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                |                                                                  |
[INFO] [stderr]                |                                                                  required by this formatting parameter
[INFO] [stderr]                |
[INFO] [stderr]                = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]                = note: required for `&Token` to implement `Debug`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Debug)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:642:27
[INFO] [stderr]                |
[INFO] [stderr]            642 |         while self.peek() == &Token::LBracket {
[INFO] [stderr]                |               ----------- ^^ ---------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:650:96
[INFO] [stderr]                |
[INFO] [stderr]            650 |                         message: format!("expected positive integer array size, found '{:?}'", other),
[INFO] [stderr]                |                                                                                        ----    ^^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                |                                                                                        |
[INFO] [stderr]                |                                                                                        required by this formatting parameter
[INFO] [stderr]                |
[INFO] [stderr]                = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Debug)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:674:27
[INFO] [stderr]                |
[INFO] [stderr]            674 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |               ----------- ^^ -------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:674:60
[INFO] [stderr]                |
[INFO] [stderr]            674 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                |
[INFO] [stderr]                |                                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:706:27
[INFO] [stderr]                |
[INFO] [stderr]            706 |         while self.peek() == &Token::ColonColon {
[INFO] [stderr]                |               ----------- ^^ ------------------ &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:714:24
[INFO] [stderr]                |
[INFO] [stderr]            714 |         if self.peek() == &Token::LParen {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:739:32
[INFO] [stderr]                |
[INFO] [stderr]            739 |                 if self.peek() == &Token::Assign {
[INFO] [stderr]                |                    ----------- ^^ -------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:763:27
[INFO] [stderr]                |
[INFO] [stderr]            763 |         while self.peek() == &Token::Else {
[INFO] [stderr]                |               ----------- ^^ ------------ &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:765:28
[INFO] [stderr]                |
[INFO] [stderr]            765 |             if self.peek() == &Token::If {
[INFO] [stderr]                |                ----------- ^^ ---------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:806:38
[INFO] [stderr]                |
[INFO] [stderr]            806 |         let ty_hint = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:814:35
[INFO] [stderr]                |
[INFO] [stderr]            814 |         let init = if self.peek() == &Token::Assign {
[INFO] [stderr]                |                       ----------- ^^ -------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:835:38
[INFO] [stderr]                |
[INFO] [stderr]            835 |         let ty_hint = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:857:24
[INFO] [stderr]                |
[INFO] [stderr]            857 |         if self.peek() == &Token::Semicolon {
[INFO] [stderr]                |            ----------- ^^ ----------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:887:35
[INFO] [stderr]                |
[INFO] [stderr]            887 |                 while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                       ----------- ^^ -------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:887:68
[INFO] [stderr]                |
[INFO] [stderr]            887 |                 while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                        ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                        |
[INFO] [stderr]                |                                                        &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:892:36
[INFO] [stderr]                |
[INFO] [stderr]            892 |                     if self.peek() == &Token::Comma {
[INFO] [stderr]                |                        ----------- ^^ ------------- &Token
[INFO] [stderr]                |                        |
[INFO] [stderr]                |                        &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:929:32
[INFO] [stderr]                |
[INFO] [stderr]            929 |                 if self.peek() == &Token::ColonColon || self.peek() == &Token::Dot {
[INFO] [stderr]                |                    ----------- ^^ ------------------ &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:929:69
[INFO] [stderr]                |
[INFO] [stderr]            929 |                 if self.peek() == &Token::ColonColon || self.peek() == &Token::Dot {
[INFO] [stderr]                |                                                         ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                         |
[INFO] [stderr]                |                                                         &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:934:33
[INFO] [stderr]                |
[INFO] [stderr]            934 |                         if *tok == Token::ColonColon {
[INFO] [stderr]                |                            ---- ^^ ----------------- Token
[INFO] [stderr]                |                            |
[INFO] [stderr]                |                            Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:938:33
[INFO] [stderr]                |
[INFO] [stderr]            938 |                         if *tok != Token::Dot && !matches!(tok, Token::Identifier(_)) {
[INFO] [stderr]                |                            ---- ^^ ---------- Token
[INFO] [stderr]                |                            |
[INFO] [stderr]                |                            Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:946:43
[INFO] [stderr]                |
[INFO] [stderr]            946 |                         while self.peek() == &Token::Dot {
[INFO] [stderr]                |                               ----------- ^^ ----------- &Token
[INFO] [stderr]                |                               |
[INFO] [stderr]                |                               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:952:43
[INFO] [stderr]                |
[INFO] [stderr]            952 |                         while self.peek() == &Token::ColonColon {
[INFO] [stderr]                |                               ----------- ^^ ------------------ &Token
[INFO] [stderr]                |                               |
[INFO] [stderr]                |                               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:958:56
[INFO] [stderr]                |
[INFO] [stderr]            958 |                         let type_args = if self.peek() == &Token::Lt {
[INFO] [stderr]                |                                            ----------- ^^ ---------- &Token
[INFO] [stderr]                |                                            |
[INFO] [stderr]                |                                            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:966:44
[INFO] [stderr]                |
[INFO] [stderr]            966 | ...                   if self.peek() == &Token::LParen {
[INFO] [stderr]                |                          ----------- ^^ -------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:984:51
[INFO] [stderr]                |
[INFO] [stderr]            984 | ...                   } else if self.peek() == &Token::LBrace
[INFO] [stderr]                |                                 ----------- ^^ -------------- &Token
[INFO] [stderr]                |                                 |
[INFO] [stderr]                |                                 &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:985:54
[INFO] [stderr]                |
[INFO] [stderr]            985 | ...                   && (self.peek_nth(1) == &Token::RBrace
[INFO] [stderr]                |                           ---------------- ^^ -------------- &Token
[INFO] [stderr]                |                           |
[INFO] [stderr]                |                           &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:986:110
[INFO] [stderr]                |
[INFO] [stderr]            986 | ...                   || (matches!(self.peek_nth(1), Token::Identifier(_)) && self.peek_nth(2) == &Token::Colon))
[INFO] [stderr]                |                                                                               ---------------- ^^ ------------- &Token
[INFO] [stderr]                |                                                                               |
[INFO] [stderr]                |                                                                               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:990:48
[INFO] [stderr]                |
[INFO] [stderr]            990 | ...                   if self.peek() != &Token::RBrace {
[INFO] [stderr]                |                          ----------- ^^ -------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:996:56
[INFO] [stderr]                |
[INFO] [stderr]            996 | ...                   if self.peek() == &Token::Comma {
[INFO] [stderr]                |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:998:60
[INFO] [stderr]                |
[INFO] [stderr]            998 | ...                   if self.peek() == &Token::RBrace {
[INFO] [stderr]                |                          ----------- ^^ -------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1022:39
[INFO] [stderr]                 |
[INFO] [stderr]            1022 |                 } else if self.peek() == &Token::Lt {
[INFO] [stderr]                 |                           ----------- ^^ ---------- &Token
[INFO] [stderr]                 |                           |
[INFO] [stderr]                 |                           &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1037:39
[INFO] [stderr]                 |
[INFO] [stderr]            1037 |                 } else if self.peek() == &Token::LParen {
[INFO] [stderr]                 |                           ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                           |
[INFO] [stderr]                 |                           &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1044:39
[INFO] [stderr]                 |
[INFO] [stderr]            1044 |                 } else if self.peek() == &Token::LBrace
[INFO] [stderr]                 |                           ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                           |
[INFO] [stderr]                 |                           &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1045:42
[INFO] [stderr]                 |
[INFO] [stderr]            1045 |                     && (self.peek_nth(1) == &Token::RBrace
[INFO] [stderr]                 |                         ---------------- ^^ -------------- &Token
[INFO] [stderr]                 |                         |
[INFO] [stderr]                 |                         &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1046:98
[INFO] [stderr]                 |
[INFO] [stderr]            1046 |                         || (matches!(self.peek_nth(1), Token::Identifier(_)) && self.peek_nth(2) == &Token::Colon))
[INFO] [stderr]                 |                                                                                 ---------------- ^^ ------------- &Token
[INFO] [stderr]                 |                                                                                 |
[INFO] [stderr]                 |                                                                                 &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1050:36
[INFO] [stderr]                 |
[INFO] [stderr]            1050 |                     if self.peek() != &Token::RBrace {
[INFO] [stderr]                 |                        ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                        |
[INFO] [stderr]                 |                        &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1056:44
[INFO] [stderr]                 |
[INFO] [stderr]            1056 | ...                   if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                          |
[INFO] [stderr]                 |                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1058:48
[INFO] [stderr]                 |
[INFO] [stderr]            1058 | ...                   if self.peek() == &Token::RBrace {
[INFO] [stderr]                 |                          ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                          |
[INFO] [stderr]                 |                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1091:32
[INFO] [stderr]                 |
[INFO] [stderr]            1091 |                 if self.peek() != &Token::RBracket {
[INFO] [stderr]                 |                    ----------- ^^ ---------------- &Token
[INFO] [stderr]                 |                    |
[INFO] [stderr]                 |                    &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1095:40
[INFO] [stderr]                 |
[INFO] [stderr]            1095 |                         if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                            ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                            |
[INFO] [stderr]                 |                            &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1097:44
[INFO] [stderr]                 |
[INFO] [stderr]            1097 | ...                   if self.peek() == &Token::RBracket {
[INFO] [stderr]                 |                          ----------- ^^ ---------------- &Token
[INFO] [stderr]                 |                          |
[INFO] [stderr]                 |                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1131:79
[INFO] [stderr]                 |
[INFO] [stderr]            1131 |                         message: format!("expected expression, found '{:?}'", op),
[INFO] [stderr]                 |                                                                       ----    ^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                 |                                                                       |
[INFO] [stderr]                 |                                                                       required by this formatting parameter
[INFO] [stderr]                 |
[INFO] [stderr]                 = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(Debug)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1141:24
[INFO] [stderr]                 |
[INFO] [stderr]            1141 |             if next_op == &Token::Eof {
[INFO] [stderr]                 |                ------- ^^ ----------- &Token
[INFO] [stderr]                 |                |
[INFO] [stderr]                 |                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1149:29
[INFO] [stderr]                 |
[INFO] [stderr]            1149 |                 if op_token == Token::Question {
[INFO] [stderr]                 |                    -------- ^^ --------------- Token
[INFO] [stderr]                 |                    |
[INFO] [stderr]                 |                    Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1163:29
[INFO] [stderr]                 |
[INFO] [stderr]            1163 |                 if op_token == Token::Dot {
[INFO] [stderr]                 |                    -------- ^^ ---------- Token
[INFO] [stderr]                 |                    |
[INFO] [stderr]                 |                    Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1167:36
[INFO] [stderr]                 |
[INFO] [stderr]            1167 |                     if self.peek() == &Token::LParen {
[INFO] [stderr]                 |                        ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                        |
[INFO] [stderr]                 |                        &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1170:40
[INFO] [stderr]                 |
[INFO] [stderr]            1170 |                         if self.peek() != &Token::RParen {
[INFO] [stderr]                 |                            ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                            |
[INFO] [stderr]                 |                            &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1174:48
[INFO] [stderr]                 |
[INFO] [stderr]            1174 | ...                   if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                          |
[INFO] [stderr]                 |                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1195:36
[INFO] [stderr]                 |
[INFO] [stderr]            1195 |                 } else if op_token == Token::LBracket {
[INFO] [stderr]                 |                           -------- ^^ --------------- Token
[INFO] [stderr]                 |                           |
[INFO] [stderr]                 |                           Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0308]: mismatched types
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1269:19
[INFO] [stderr]                 |
[INFO] [stderr]            1269 |             Some((tok.clone(), *span))
[INFO] [stderr]                 |                   ^^^^^^^^^^^ expected `Token`, found `&Token`
[INFO] [stderr]                 |
[INFO] [stderr]            note: `Token` does not implement `Clone`, so `&Token` was cloned instead
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1269:19
[INFO] [stderr]                 |
[INFO] [stderr]            1269 |             Some((tok.clone(), *span))
[INFO] [stderr]                 |                   ^^^
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Clone)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(Clone)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1277:19
[INFO] [stderr]                 |
[INFO] [stderr]            1277 |         if actual == expected {
[INFO] [stderr]                 |            ------ ^^ -------- &Token
[INFO] [stderr]                 |            |
[INFO] [stderr]                 |            &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1284:67
[INFO] [stderr]                 |
[INFO] [stderr]            1284 |                 message: format!("expected '{:?}', found '{:?}'", expected, actual),
[INFO] [stderr]                 |                                             ----                  ^^^^^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                 |                                             |
[INFO] [stderr]                 |                                             required by this formatting parameter
[INFO] [stderr]                 |
[INFO] [stderr]                 = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]                 = note: required for `&Token` to implement `Debug`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(Debug)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1301:71
[INFO] [stderr]                 |
[INFO] [stderr]            1301 |                 message: format!("expected identifier, found '{:?}'", actual),
[INFO] [stderr]                 |                                                               ----    ^^^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                 |                                                               |
[INFO] [stderr]                 |                                                               required by this formatting parameter
[INFO] [stderr]                 |
[INFO] [stderr]                 = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]                 = note: required for `&Token` to implement `Debug`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(Debug)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1313:28
[INFO] [stderr]                 |
[INFO] [stderr]            1313 |             if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                |
[INFO] [stderr]                 |                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1327:44
[INFO] [stderr]                 |
[INFO] [stderr]            1327 |         if parsed.is_some() && self.peek() == &Token::LParen {
[INFO] [stderr]                 |                                ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                                |
[INFO] [stderr]                 |                                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1338:24
[INFO] [stderr]                 |
[INFO] [stderr]            1338 |         if self.peek() != &Token::RParen {
[INFO] [stderr]                 |            ----------- ^^ -------------- &Token
[INFO] [stderr]                 |            |
[INFO] [stderr]                 |            &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1342:32
[INFO] [stderr]                 |
[INFO] [stderr]            1342 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                    |
[INFO] [stderr]                 |                    &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1356:21
[INFO] [stderr]                 |
[INFO] [stderr]            1356 |             if next == &Token::Semicolon {
[INFO] [stderr]                 |                ---- ^^ ----------------- &Token
[INFO] [stderr]                 |                |
[INFO] [stderr]                 |                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1360:21
[INFO] [stderr]                 |
[INFO] [stderr]            1360 |             if next == &Token::RBrace || next == &Token::Fn {
[INFO] [stderr]                 |                ---- ^^ -------------- &Token
[INFO] [stderr]                 |                |
[INFO] [stderr]                 |                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1360:47
[INFO] [stderr]                 |
[INFO] [stderr]            1360 |             if next == &Token::RBrace || next == &Token::Fn {
[INFO] [stderr]                 |                                          ---- ^^ ---------- &Token
[INFO] [stderr]                 |                                          |
[INFO] [stderr]                 |                                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]              --> compiler/src/resolver.rs:63:25
[INFO] [stderr]               |
[INFO] [stderr]            63 |             let lexer = Lexer::new(&source);
[INFO] [stderr]               |                         ^^^^^ unsatisfied trait bound
[INFO] [stderr]               |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]              --> compiler/src/resolver.rs:63:25
[INFO] [stderr]               |
[INFO] [stderr]            63 |             let lexer = Lexer::new(&source);
[INFO] [stderr]               |                         ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]               |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied in `lexer::Lexer<'_>`
[INFO] [stderr]               --> compiler/src/resolver.rs:63:17
[INFO] [stderr]                |
[INFO] [stderr]             63 |             let lexer = Lexer::new(&source);
[INFO] [stderr]                |                 ^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: within `lexer::Lexer<'_>`, the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required because it appears within the type `lexer::Lexer<'_>`
[INFO] [stderr]               --> compiler/src/lexer.rs:338:12
[INFO] [stderr]                |
[INFO] [stderr]            338 | pub struct Lexer<'src> {
[INFO] [stderr]                |            ^^^^^
[INFO] [stderr]                = note: all local variables must have a statically known size
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]              --> compiler/src/resolver.rs:64:46
[INFO] [stderr]               |
[INFO] [stderr]            64 |             let (tokens, lex_errors) = lexer.tokenize();
[INFO] [stderr]               |                                              ^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]               |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: aborting due to 220 previous errors
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            Some errors have detailed explanations: E0277, E0308, E0369, E0599.
[INFO] [stderr]            
[INFO] [stderr]            For more information about an error, try `rustc --explain E0277`.
[INFO] [stderr] help: to report this as a bug, open an issue at https://github.com/rust-lang/rust/issues, quoting the full output of this command
[INFO] [stderr] help: to possibly apply more fixes, pass in the `--broken-code` flag
[INFO] [stderr] note: original diagnostics will follow:
[INFO] [stderr]    Migrating compiler/tests/integration_tests.rs from 2021 edition to 2024
[INFO] [stderr] error: errors present after applying fixes to crate `atlas`
[INFO] [stderr]  --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs
[INFO] [stderr]  ::: compiler/src/lexer.rs
[INFO] [stderr]  ::: compiler/src/parser/parse.rs
[INFO] [stderr]  ::: compiler/src/resolver.rs
[INFO] [stderr]   = cause: error: expected one of `(`, `,`, `::`, or `=`, found `+`
[INFO] [stderr]              --> compiler/src/lexer.rs:17:16
[INFO] [stderr]               |
[INFO] [stderr]            17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stderr]               |                ^ expected one of `(`, `,`, `::`, or `=`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `logos` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:18:3
[INFO] [stderr]               |
[INFO] [stderr]            18 | #[logos(skip r"[ \t\n\r]+")]
[INFO] [stderr]               |   ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]               = note: `logos` is in scope, but it is a crate, not an attribute
[INFO] [stderr]            help: `logos` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `logos` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:19:3
[INFO] [stderr]               |
[INFO] [stderr]            19 | #[logos(skip r"//[^\n]*")]
[INFO] [stderr]               |   ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]               = note: `logos` is in scope, but it is a crate, not an attribute
[INFO] [stderr]            help: `logos` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:21:7
[INFO] [stderr]               |
[INFO] [stderr]            21 |     #[regex("[0-9]+[a-zA-Z0-9]*", parse_int)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:24:7
[INFO] [stderr]               |
[INFO] [stderr]            24 |     #[regex("[0-9]+\\.[0-9]+", |lex| lex.slice().parse::<f64>().ok())]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:27:7
[INFO] [stderr]               |
[INFO] [stderr]            27 |     #[token("true", |_| true)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:28:7
[INFO] [stderr]               |
[INFO] [stderr]            28 |     #[token("false", |_| false)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:31:7
[INFO] [stderr]               |
[INFO] [stderr]            31 |     #[regex("'([^'\\\\]|\\\\.)*'", parse_char)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:34:7
[INFO] [stderr]               |
[INFO] [stderr]            34 |     #[regex("\"([^\"\\n\\\\]|\\\\.)*\"", parse_string)]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:38:7
[INFO] [stderr]               |
[INFO] [stderr]            38 |     #[token("var")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:40:7
[INFO] [stderr]               |
[INFO] [stderr]            40 |     #[token("const")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:42:7
[INFO] [stderr]               |
[INFO] [stderr]            42 |     #[token("fn")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:44:7
[INFO] [stderr]               |
[INFO] [stderr]            44 |     #[token("struct")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:46:7
[INFO] [stderr]               |
[INFO] [stderr]            46 |     #[token("class")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:48:7
[INFO] [stderr]               |
[INFO] [stderr]            48 |     #[token("enum")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:50:7
[INFO] [stderr]               |
[INFO] [stderr]            50 |     #[token("choice")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:52:7
[INFO] [stderr]               |
[INFO] [stderr]            52 |     #[token("match")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:54:7
[INFO] [stderr]               |
[INFO] [stderr]            54 |     #[token("if")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:56:7
[INFO] [stderr]               |
[INFO] [stderr]            56 |     #[token("else")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:58:7
[INFO] [stderr]               |
[INFO] [stderr]            58 |     #[token("while")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:60:7
[INFO] [stderr]               |
[INFO] [stderr]            60 |     #[token("break")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:62:7
[INFO] [stderr]               |
[INFO] [stderr]            62 |     #[token("continue")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:64:7
[INFO] [stderr]               |
[INFO] [stderr]            64 |     #[token("return")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:66:7
[INFO] [stderr]               |
[INFO] [stderr]            66 |     #[token("import")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:68:7
[INFO] [stderr]               |
[INFO] [stderr]            68 |     #[token("export")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:70:7
[INFO] [stderr]               |
[INFO] [stderr]            70 |     #[token("public")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:72:7
[INFO] [stderr]               |
[INFO] [stderr]            72 |     #[token("private")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:74:7
[INFO] [stderr]               |
[INFO] [stderr]            74 |     #[token("where")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:76:7
[INFO] [stderr]               |
[INFO] [stderr]            76 |     #[token("as")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:78:7
[INFO] [stderr]               |
[INFO] [stderr]            78 |     #[token("and")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:80:7
[INFO] [stderr]               |
[INFO] [stderr]            80 |     #[token("or")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:82:7
[INFO] [stderr]               |
[INFO] [stderr]            82 |     #[token("not")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:84:7
[INFO] [stderr]               |
[INFO] [stderr]            84 |     #[token("extern")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:86:7
[INFO] [stderr]               |
[INFO] [stderr]            86 |     #[token("self")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:88:7
[INFO] [stderr]               |
[INFO] [stderr]            88 |     #[token("null")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:92:7
[INFO] [stderr]               |
[INFO] [stderr]            92 |     #[token("int")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:94:7
[INFO] [stderr]               |
[INFO] [stderr]            94 |     #[token("uint")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:96:7
[INFO] [stderr]               |
[INFO] [stderr]            96 |     #[token("int8")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]              --> compiler/src/lexer.rs:98:7
[INFO] [stderr]               |
[INFO] [stderr]            98 |     #[token("int16")]
[INFO] [stderr]               |       ^^^^^
[INFO] [stderr]               |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Logos)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:100:7
[INFO] [stderr]                |
[INFO] [stderr]            100 |     #[token("int32")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:102:7
[INFO] [stderr]                |
[INFO] [stderr]            102 |     #[token("int64")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:104:7
[INFO] [stderr]                |
[INFO] [stderr]            104 |     #[token("uint8")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:106:7
[INFO] [stderr]                |
[INFO] [stderr]            106 |     #[token("uint16")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:108:7
[INFO] [stderr]                |
[INFO] [stderr]            108 |     #[token("uint32")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:110:7
[INFO] [stderr]                |
[INFO] [stderr]            110 |     #[token("uint64")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:112:7
[INFO] [stderr]                |
[INFO] [stderr]            112 |     #[token("float")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:114:7
[INFO] [stderr]                |
[INFO] [stderr]            114 |     #[token("float32")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:116:7
[INFO] [stderr]                |
[INFO] [stderr]            116 |     #[token("float64")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:118:7
[INFO] [stderr]                |
[INFO] [stderr]            118 |     #[token("bool")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:120:7
[INFO] [stderr]                |
[INFO] [stderr]            120 |     #[token("char")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:124:7
[INFO] [stderr]                |
[INFO] [stderr]            124 |     #[token("+")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:126:7
[INFO] [stderr]                |
[INFO] [stderr]            126 |     #[token("-")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:128:7
[INFO] [stderr]                |
[INFO] [stderr]            128 |     #[token("*")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:130:7
[INFO] [stderr]                |
[INFO] [stderr]            130 |     #[token("/")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:132:7
[INFO] [stderr]                |
[INFO] [stderr]            132 |     #[token("%")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:134:7
[INFO] [stderr]                |
[INFO] [stderr]            134 |     #[token("==")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:136:7
[INFO] [stderr]                |
[INFO] [stderr]            136 |     #[token("!=")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:138:7
[INFO] [stderr]                |
[INFO] [stderr]            138 |     #[token("<=")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:140:7
[INFO] [stderr]                |
[INFO] [stderr]            140 |     #[token(">=")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:142:7
[INFO] [stderr]                |
[INFO] [stderr]            142 |     #[token("<")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:144:7
[INFO] [stderr]                |
[INFO] [stderr]            144 |     #[token(">")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:146:7
[INFO] [stderr]                |
[INFO] [stderr]            146 |     #[token("=")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:148:7
[INFO] [stderr]                |
[INFO] [stderr]            148 |     #[token("!")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:150:7
[INFO] [stderr]                |
[INFO] [stderr]            150 |     #[token("&&")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:152:7
[INFO] [stderr]                |
[INFO] [stderr]            152 |     #[token("||")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:154:7
[INFO] [stderr]                |
[INFO] [stderr]            154 |     #[token("@")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:156:7
[INFO] [stderr]                |
[INFO] [stderr]            156 |     #[token("?")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:158:7
[INFO] [stderr]                |
[INFO] [stderr]            158 |     #[token("::")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:160:7
[INFO] [stderr]                |
[INFO] [stderr]            160 |     #[token(":")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:162:7
[INFO] [stderr]                |
[INFO] [stderr]            162 |     #[token(";")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:164:7
[INFO] [stderr]                |
[INFO] [stderr]            164 |     #[token(",")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:166:7
[INFO] [stderr]                |
[INFO] [stderr]            166 |     #[token("...")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:168:7
[INFO] [stderr]                |
[INFO] [stderr]            168 |     #[token(".")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:170:7
[INFO] [stderr]                |
[INFO] [stderr]            170 |     #[token("=>")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:172:7
[INFO] [stderr]                |
[INFO] [stderr]            172 |     #[token("(")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:174:7
[INFO] [stderr]                |
[INFO] [stderr]            174 |     #[token(")")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:176:7
[INFO] [stderr]                |
[INFO] [stderr]            176 |     #[token("{")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:178:7
[INFO] [stderr]                |
[INFO] [stderr]            178 |     #[token("}")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:180:7
[INFO] [stderr]                |
[INFO] [stderr]            180 |     #[token("[")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:182:7
[INFO] [stderr]                |
[INFO] [stderr]            182 |     #[token("]")]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `regex` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:185:7
[INFO] [stderr]                |
[INFO] [stderr]            185 |     #[regex("[a-zA-Z_][a-zA-Z0-9_]*", |lex| lex.slice().to_string())]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `regex` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: cannot find attribute `token` in this scope
[INFO] [stderr]               --> compiler/src/lexer.rs:188:7
[INFO] [stderr]                |
[INFO] [stderr]            188 |     #[token("/*", block_comment)]
[INFO] [stderr]                |       ^^^^^
[INFO] [stderr]                |
[INFO] [stderr]            help: `token` is an attribute that can be used by the derive macro `Logos`, you might be missing a `derive` attribute
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Logos)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:194:24
[INFO] [stderr]                |
[INFO] [stderr]            194 | fn parse_int(lex: &mut logos::Lexer<Token>) -> Option<(i64, Option<IntSuffix>)> {
[INFO] [stderr]                |                        ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required by a bound in `logos::Lexer`
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:34
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                |                                  ^^^^^^^^^^^^^^ required by this bound in `Lexer`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:227:25
[INFO] [stderr]                |
[INFO] [stderr]            227 | fn parse_char(lex: &mut logos::Lexer<Token>) -> Option<char> {
[INFO] [stderr]                |                         ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required by a bound in `logos::Lexer`
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:34
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                |                                  ^^^^^^^^^^^^^^ required by this bound in `Lexer`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:254:27
[INFO] [stderr]                |
[INFO] [stderr]            254 | fn parse_string(lex: &mut logos::Lexer<Token>) -> Option<String> {
[INFO] [stderr]                |                           ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required by a bound in `logos::Lexer`
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:34
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                |                                  ^^^^^^^^^^^^^^ required by this bound in `Lexer`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:277:28
[INFO] [stderr]                |
[INFO] [stderr]            277 | fn block_comment(lex: &mut logos::Lexer<Token>) -> logos::Filter<Token> {
[INFO] [stderr]                |                            ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required by a bound in `logos::Lexer`
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:34
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                |                                  ^^^^^^^^^^^^^^ required by this bound in `Lexer`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:338:1
[INFO] [stderr]                |
[INFO] [stderr]            338 | pub struct Lexer<'src> {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]              --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:14:5
[INFO] [stderr]               |
[INFO] [stderr]            14 |     source: &'source Token::Source,
[INFO] [stderr]               |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]               |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:343:12
[INFO] [stderr]                |
[INFO] [stderr]            343 | impl<'src> Lexer<'src> {
[INFO] [stderr]                |            ^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:344:38
[INFO] [stderr]                |
[INFO] [stderr]            344 |     pub fn new(source: &'src str) -> Self {
[INFO] [stderr]                |                                      ^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:351:25
[INFO] [stderr]                |
[INFO] [stderr]            351 |     pub fn tokenize(mut self) -> (Vec<Spanned<Token>>, Vec<AtlasError>) {
[INFO] [stderr]                |                         ^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `slice` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:195:21
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            195 |     let slice = lex.slice();
[INFO] [stderr]                |                     ^^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `slice` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:228:17
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            228 |     let s = lex.slice();
[INFO] [stderr]                |                 ^^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `slice` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:255:17
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            255 |     let s = lex.slice();
[INFO] [stderr]                |                 ^^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `remainder` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:279:25
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            279 |     let remainder = lex.remainder();
[INFO] [stderr]                |                         ^^^^^^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `bump` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:304:13
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            304 |         lex.bump(end_idx);
[INFO] [stderr]                |             ^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `bump` exists for mutable reference `&mut logos::Lexer<'_, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:307:13
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            307 |         lex.bump(remainder.len());
[INFO] [stderr]                |             ^^^^ method cannot be called on `&mut logos::Lexer<'_, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:345:9
[INFO] [stderr]                |
[INFO] [stderr]            345 |         Self {
[INFO] [stderr]                |         ^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: no variant, associated function, or constant named `lexer` found for enum `Token` in the current scope
[INFO] [stderr]               --> compiler/src/lexer.rs:347:27
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- variant, associated function, or constant `lexer` not found for this enum
[INFO] [stderr]            ...
[INFO] [stderr]            347 |             inner: Token::lexer(source),
[INFO] [stderr]                |                           ^^^^^ variant, associated function, or constant not found in `Token`
[INFO] [stderr]                |
[INFO] [stderr]                = help: items from traits can only be used if the trait is implemented and in scope
[INFO] [stderr]                = note: the following trait defines an item `lexer`, perhaps you need to implement it:
[INFO] [stderr]                        candidate #1: `Logos`
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied in `lexer::Lexer<'src>`
[INFO] [stderr]               --> compiler/src/lexer.rs:345:9
[INFO] [stderr]                |
[INFO] [stderr]            345 | /         Self {
[INFO] [stderr]            346 | |             source,
[INFO] [stderr]            347 | |             inner: Token::lexer(source),
[INFO] [stderr]            348 | |         }
[INFO] [stderr]                | |_________^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: within `lexer::Lexer<'src>`, the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required because it appears within the type `lexer::Lexer<'src>`
[INFO] [stderr]               --> compiler/src/lexer.rs:338:12
[INFO] [stderr]                |
[INFO] [stderr]            338 | pub struct Lexer<'src> {
[INFO] [stderr]                |            ^^^^^
[INFO] [stderr]                = note: structs must have a statically known size to be initialized
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'src>` is not satisfied in `lexer::Lexer<'src>`
[INFO] [stderr]               --> compiler/src/lexer.rs:351:25
[INFO] [stderr]                |
[INFO] [stderr]            351 |     pub fn tokenize(mut self) -> (Vec<Spanned<Token>>, Vec<AtlasError>) {
[INFO] [stderr]                |                         ^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: within `lexer::Lexer<'src>`, the trait `Logos<'src>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required because it appears within the type `lexer::Lexer<'src>`
[INFO] [stderr]               --> compiler/src/lexer.rs:338:12
[INFO] [stderr]                |
[INFO] [stderr]            338 | pub struct Lexer<'src> {
[INFO] [stderr]                |            ^^^^^
[INFO] [stderr]                = help: unsized fn params are gated as an unstable feature
[INFO] [stderr]            help: function arguments must have a statically known size, borrowed types always have a known size
[INFO] [stderr]                |
[INFO] [stderr]            351 |     pub fn tokenize(mut &self) -> (Vec<Spanned<Token>>, Vec<AtlasError>) {
[INFO] [stderr]                |                         +
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `next` exists for struct `logos::Lexer<'src, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:357:42
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            357 |         while let Some(res) = self.inner.next() {
[INFO] [stderr]                |                                          ^^^^ method cannot be called on `logos::Lexer<'src, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]               ::: /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lexer.rs:13:1
[INFO] [stderr]                |
[INFO] [stderr]             13 | pub struct Lexer<'source, Token: Logos<'source>> {
[INFO] [stderr]                | ------------------------------------------------ doesn't satisfy `logos::Lexer<'src, Token>: Iterator`
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]                        which is required by `logos::Lexer<'src, Token>: Iterator`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `span` exists for struct `logos::Lexer<'src, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:358:46
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            358 |             let span = Span::from(self.inner.span());
[INFO] [stderr]                |                                              ^^^^ method cannot be called on `logos::Lexer<'src, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0599]: the method `span` exists for struct `logos::Lexer<'src, Token>`, but its trait bounds were not satisfied
[INFO] [stderr]               --> compiler/src/lexer.rs:371:44
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | -------------- doesn't satisfy `Token: Logos<'_>`
[INFO] [stderr]            ...
[INFO] [stderr]            371 |                     let range = self.inner.span();
[INFO] [stderr]                |                                            ^^^^ method cannot be called on `logos::Lexer<'src, Token>` due to unsatisfied trait bounds
[INFO] [stderr]                |
[INFO] [stderr]                = note: the following trait bounds were not satisfied:
[INFO] [stderr]                        `Token: Logos<'_>`
[INFO] [stderr]            note: the trait `Logos` must be implemented
[INFO] [stderr]               --> /opt/rustwide/cargo-home/registry/src/index.crates.io-1949cf8c6b5b557f/logos-0.14.4/src/lib.rs:44:1
[INFO] [stderr]                |
[INFO] [stderr]             44 | pub trait Logos<'source>: Sized {
[INFO] [stderr]                | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: can't compare `Token` with `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:361:30
[INFO] [stderr]                |
[INFO] [stderr]            361 |                     if token == Token::UnterminatedBlockComment {
[INFO] [stderr]                |                              ^^ no implementation for `Token == Token`
[INFO] [stderr]                |
[INFO] [stderr]                = help: the trait `PartialEq` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]              --> compiler/src/parser/parse.rs:26:27
[INFO] [stderr]               |
[INFO] [stderr]            26 |         while self.peek() != &Token::Eof {
[INFO] [stderr]               |               ----------- ^^ ----------- &Token
[INFO] [stderr]               |               |
[INFO] [stderr]               |               &Token
[INFO] [stderr]               |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(PartialEq)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]              --> compiler/src/parser/parse.rs:41:42
[INFO] [stderr]               |
[INFO] [stderr]            41 |         let is_exported = if self.peek() == &Token::Export {
[INFO] [stderr]               |                              ----------- ^^ -------------- &Token
[INFO] [stderr]               |                              |
[INFO] [stderr]               |                              &Token
[INFO] [stderr]               |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(PartialEq)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]              --> compiler/src/parser/parse.rs:80:120
[INFO] [stderr]               |
[INFO] [stderr]            80 |                     message: format!("expected top-level item (e.g. fn, struct, class, import, extern), found '{:?}'", token),
[INFO] [stderr]               |                                                                                                                ----    ^^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]               |                                                                                                                |
[INFO] [stderr]               |                                                                                                                required by this formatting parameter
[INFO] [stderr]               |
[INFO] [stderr]               = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]               = note: required for `&Token` to implement `Debug`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Debug)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]              --> compiler/src/parser/parse.rs:97:88
[INFO] [stderr]               |
[INFO] [stderr]            97 |                     message: format!("expected ABI string (e.g. \"C\"), found '{:?}'", t),
[INFO] [stderr]               |                                                                                ----    ^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]               |                                                                                |
[INFO] [stderr]               |                                                                                required by this formatting parameter
[INFO] [stderr]               |
[INFO] [stderr]               = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 + #[derive(Debug)]
[INFO] [stderr]            21 | pub enum Token {
[INFO] [stderr]               |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:119:37
[INFO] [stderr]                |
[INFO] [stderr]            119 |         let ret_ty = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                         ----------- ^^ ------------- &Token
[INFO] [stderr]                |                         |
[INFO] [stderr]                |                         &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:142:24
[INFO] [stderr]                |
[INFO] [stderr]            142 |         if self.peek() == &Token::RParen {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:146:24
[INFO] [stderr]                |
[INFO] [stderr]            146 |         if self.peek() == &Token::Ellipsis {
[INFO] [stderr]                |            ----------- ^^ ---------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:154:28
[INFO] [stderr]                |
[INFO] [stderr]            154 |             if self.peek() != &Token::Comma {
[INFO] [stderr]                |                ----------- ^^ ------------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:159:28
[INFO] [stderr]                |
[INFO] [stderr]            159 |             if self.peek() == &Token::Ellipsis {
[INFO] [stderr]                |                ----------- ^^ ---------------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:174:27
[INFO] [stderr]                |
[INFO] [stderr]            174 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |               ----------- ^^ -------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:174:60
[INFO] [stderr]                |
[INFO] [stderr]            174 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                |
[INFO] [stderr]                |                                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:195:24
[INFO] [stderr]                |
[INFO] [stderr]            195 |         if self.peek() != &Token::RBrace {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:199:32
[INFO] [stderr]                |
[INFO] [stderr]            199 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:216:24
[INFO] [stderr]                |
[INFO] [stderr]            216 |         if self.peek() == &Token::Lt {
[INFO] [stderr]                |            ----------- ^^ ---------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:221:32
[INFO] [stderr]                |
[INFO] [stderr]            221 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:231:24
[INFO] [stderr]                |
[INFO] [stderr]            231 |         if self.peek() != &Token::RBrace {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:236:32
[INFO] [stderr]                |
[INFO] [stderr]            236 |                 if self.peek() == &Token::LParen {
[INFO] [stderr]                |                    ----------- ^^ -------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:248:32
[INFO] [stderr]                |
[INFO] [stderr]            248 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:270:27
[INFO] [stderr]                |
[INFO] [stderr]            270 |         while self.peek() == &Token::Dot {
[INFO] [stderr]                |               ----------- ^^ ----------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:285:24
[INFO] [stderr]                |
[INFO] [stderr]            285 |         if self.peek() == &Token::Lt {
[INFO] [stderr]                |            ----------- ^^ ---------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:290:32
[INFO] [stderr]                |
[INFO] [stderr]            290 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:300:27
[INFO] [stderr]                |
[INFO] [stderr]            300 |         while self.peek() == &Token::Where {
[INFO] [stderr]                |               ----------- ^^ ------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:314:27
[INFO] [stderr]                |
[INFO] [stderr]            314 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |               ----------- ^^ -------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:314:60
[INFO] [stderr]                |
[INFO] [stderr]            314 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                |
[INFO] [stderr]                |                                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:315:45
[INFO] [stderr]                |
[INFO] [stderr]            315 |             let visibility = if self.peek() == &Token::Public {
[INFO] [stderr]                |                                 ----------- ^^ -------------- &Token
[INFO] [stderr]                |                                 |
[INFO] [stderr]                |                                 &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:318:35
[INFO] [stderr]                |
[INFO] [stderr]            318 |             } else if self.peek() == &Token::Private {
[INFO] [stderr]                |                       ----------- ^^ --------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:325:28
[INFO] [stderr]                |
[INFO] [stderr]            325 |             if self.peek() == &Token::Fn {
[INFO] [stderr]                |                ----------- ^^ ---------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:329:35
[INFO] [stderr]                |
[INFO] [stderr]            329 |             } else if self.peek() == &Token::Struct {
[INFO] [stderr]                |                       ----------- ^^ -------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:334:47
[INFO] [stderr]                |
[INFO] [stderr]            334 |                 let is_const = if self.peek() == &Token::Const {
[INFO] [stderr]                |                                   ----------- ^^ ------------- &Token
[INFO] [stderr]                |                                   |
[INFO] [stderr]                |                                   &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:374:27
[INFO] [stderr]                |
[INFO] [stderr]            374 |         while self.peek() != &Token::RParen && self.peek() != &Token::Eof {
[INFO] [stderr]                |               ----------- ^^ -------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:374:60
[INFO] [stderr]                |
[INFO] [stderr]            374 |         while self.peek() != &Token::RParen && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                |
[INFO] [stderr]                |                                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:396:37
[INFO] [stderr]                |
[INFO] [stderr]            396 |         let ret_ty = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                         ----------- ^^ ------------- &Token
[INFO] [stderr]                |                         |
[INFO] [stderr]                |                         &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:442:36
[INFO] [stderr]                |
[INFO] [stderr]            442 |                     if self.peek() == &Token::RBracket {
[INFO] [stderr]                |                        ----------- ^^ ---------------- &Token
[INFO] [stderr]                |                        |
[INFO] [stderr]                |                        &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:445:40
[INFO] [stderr]                |
[INFO] [stderr]            445 |                         if self.peek() == &Token::Assign {
[INFO] [stderr]                |                            ----------- ^^ -------------- &Token
[INFO] [stderr]                |                            |
[INFO] [stderr]                |                            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:466:24
[INFO] [stderr]                |
[INFO] [stderr]            466 |         if self.peek() == &Token::Lt {
[INFO] [stderr]                |            ----------- ^^ ---------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:471:32
[INFO] [stderr]                |
[INFO] [stderr]            471 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:483:37
[INFO] [stderr]                |
[INFO] [stderr]            483 |         let ret_ty = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                         ----------- ^^ ------------- &Token
[INFO] [stderr]                |                         |
[INFO] [stderr]                |                         &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:492:27
[INFO] [stderr]                |
[INFO] [stderr]            492 |         while self.peek() == &Token::Where {
[INFO] [stderr]                |               ----------- ^^ ------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:513:24
[INFO] [stderr]                |
[INFO] [stderr]            513 |         if self.peek() == &Token::RParen {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:518:28
[INFO] [stderr]                |
[INFO] [stderr]            518 |             if self.peek() == &Token::Comma {
[INFO] [stderr]                |                ----------- ^^ ------------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:528:35
[INFO] [stderr]                |
[INFO] [stderr]            528 |         let name = if self.peek() == &Token::SelfToken {
[INFO] [stderr]                |                       ----------- ^^ ----------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:535:44
[INFO] [stderr]                |
[INFO] [stderr]            535 |         if name.0 == "self" && self.peek() != &Token::Colon {
[INFO] [stderr]                |                                ----------- ^^ ------------- &Token
[INFO] [stderr]                |                                |
[INFO] [stderr]                |                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:550:24
[INFO] [stderr]                |
[INFO] [stderr]            550 |         if self.peek() == &Token::LBracket && self.peek_nth(1) == &Token::RBracket {
[INFO] [stderr]                |            ----------- ^^ ---------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:550:64
[INFO] [stderr]                |
[INFO] [stderr]            550 |         if self.peek() == &Token::LBracket && self.peek_nth(1) == &Token::RBracket {
[INFO] [stderr]                |                                               ---------------- ^^ ---------------- &Token
[INFO] [stderr]                |                                               |
[INFO] [stderr]                |                                               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:564:39
[INFO] [stderr]                |
[INFO] [stderr]            564 |         let mut base = if self.peek() == &Token::At {
[INFO] [stderr]                |                           ----------- ^^ ---------- &Token
[INFO] [stderr]                |                           |
[INFO] [stderr]                |                           &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:569:28
[INFO] [stderr]                |
[INFO] [stderr]            569 |             if self.peek() == &Token::Question {
[INFO] [stderr]                |                ----------- ^^ ---------------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:597:42
[INFO] [stderr]                |
[INFO] [stderr]            597 |                     t => format!("{:?}", t).to_lowercase(),
[INFO] [stderr]                |                                   ----   ^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                |                                   |
[INFO] [stderr]                |                                   required by this formatting parameter
[INFO] [stderr]                |
[INFO] [stderr]                = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Debug)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:599:35
[INFO] [stderr]                |
[INFO] [stderr]            599 |                 while self.peek() == &Token::ColonColon {
[INFO] [stderr]                |                       ----------- ^^ ------------------ &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:605:32
[INFO] [stderr]                |
[INFO] [stderr]            605 |                 if self.peek() == &Token::Lt {
[INFO] [stderr]                |                    ----------- ^^ ---------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:611:40
[INFO] [stderr]                |
[INFO] [stderr]            611 |                         if self.peek() == &Token::Comma {
[INFO] [stderr]                |                            ----------- ^^ ------------- &Token
[INFO] [stderr]                |                            |
[INFO] [stderr]                |                            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:634:74
[INFO] [stderr]                |
[INFO] [stderr]            634 |                     message: format!("expected type name, found '{:?}'", next),
[INFO] [stderr]                |                                                                  ----    ^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                |                                                                  |
[INFO] [stderr]                |                                                                  required by this formatting parameter
[INFO] [stderr]                |
[INFO] [stderr]                = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]                = note: required for `&Token` to implement `Debug`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Debug)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:642:27
[INFO] [stderr]                |
[INFO] [stderr]            642 |         while self.peek() == &Token::LBracket {
[INFO] [stderr]                |               ----------- ^^ ---------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:650:96
[INFO] [stderr]                |
[INFO] [stderr]            650 |                         message: format!("expected positive integer array size, found '{:?}'", other),
[INFO] [stderr]                |                                                                                        ----    ^^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                |                                                                                        |
[INFO] [stderr]                |                                                                                        required by this formatting parameter
[INFO] [stderr]                |
[INFO] [stderr]                = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(Debug)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:674:27
[INFO] [stderr]                |
[INFO] [stderr]            674 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |               ----------- ^^ -------------- &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:674:60
[INFO] [stderr]                |
[INFO] [stderr]            674 |         while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                |
[INFO] [stderr]                |                                                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:706:27
[INFO] [stderr]                |
[INFO] [stderr]            706 |         while self.peek() == &Token::ColonColon {
[INFO] [stderr]                |               ----------- ^^ ------------------ &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:714:24
[INFO] [stderr]                |
[INFO] [stderr]            714 |         if self.peek() == &Token::LParen {
[INFO] [stderr]                |            ----------- ^^ -------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:739:32
[INFO] [stderr]                |
[INFO] [stderr]            739 |                 if self.peek() == &Token::Assign {
[INFO] [stderr]                |                    ----------- ^^ -------------- &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:763:27
[INFO] [stderr]                |
[INFO] [stderr]            763 |         while self.peek() == &Token::Else {
[INFO] [stderr]                |               ----------- ^^ ------------ &Token
[INFO] [stderr]                |               |
[INFO] [stderr]                |               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:765:28
[INFO] [stderr]                |
[INFO] [stderr]            765 |             if self.peek() == &Token::If {
[INFO] [stderr]                |                ----------- ^^ ---------- &Token
[INFO] [stderr]                |                |
[INFO] [stderr]                |                &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:806:38
[INFO] [stderr]                |
[INFO] [stderr]            806 |         let ty_hint = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:814:35
[INFO] [stderr]                |
[INFO] [stderr]            814 |         let init = if self.peek() == &Token::Assign {
[INFO] [stderr]                |                       ----------- ^^ -------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:835:38
[INFO] [stderr]                |
[INFO] [stderr]            835 |         let ty_hint = if self.peek() == &Token::Colon {
[INFO] [stderr]                |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:857:24
[INFO] [stderr]                |
[INFO] [stderr]            857 |         if self.peek() == &Token::Semicolon {
[INFO] [stderr]                |            ----------- ^^ ----------------- &Token
[INFO] [stderr]                |            |
[INFO] [stderr]                |            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:887:35
[INFO] [stderr]                |
[INFO] [stderr]            887 |                 while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                       ----------- ^^ -------------- &Token
[INFO] [stderr]                |                       |
[INFO] [stderr]                |                       &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:887:68
[INFO] [stderr]                |
[INFO] [stderr]            887 |                 while self.peek() != &Token::RBrace && self.peek() != &Token::Eof {
[INFO] [stderr]                |                                                        ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                        |
[INFO] [stderr]                |                                                        &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:892:36
[INFO] [stderr]                |
[INFO] [stderr]            892 |                     if self.peek() == &Token::Comma {
[INFO] [stderr]                |                        ----------- ^^ ------------- &Token
[INFO] [stderr]                |                        |
[INFO] [stderr]                |                        &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:929:32
[INFO] [stderr]                |
[INFO] [stderr]            929 |                 if self.peek() == &Token::ColonColon || self.peek() == &Token::Dot {
[INFO] [stderr]                |                    ----------- ^^ ------------------ &Token
[INFO] [stderr]                |                    |
[INFO] [stderr]                |                    &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:929:69
[INFO] [stderr]                |
[INFO] [stderr]            929 |                 if self.peek() == &Token::ColonColon || self.peek() == &Token::Dot {
[INFO] [stderr]                |                                                         ----------- ^^ ----------- &Token
[INFO] [stderr]                |                                                         |
[INFO] [stderr]                |                                                         &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:934:33
[INFO] [stderr]                |
[INFO] [stderr]            934 |                         if *tok == Token::ColonColon {
[INFO] [stderr]                |                            ---- ^^ ----------------- Token
[INFO] [stderr]                |                            |
[INFO] [stderr]                |                            Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:938:33
[INFO] [stderr]                |
[INFO] [stderr]            938 |                         if *tok != Token::Dot && !matches!(tok, Token::Identifier(_)) {
[INFO] [stderr]                |                            ---- ^^ ---------- Token
[INFO] [stderr]                |                            |
[INFO] [stderr]                |                            Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:946:43
[INFO] [stderr]                |
[INFO] [stderr]            946 |                         while self.peek() == &Token::Dot {
[INFO] [stderr]                |                               ----------- ^^ ----------- &Token
[INFO] [stderr]                |                               |
[INFO] [stderr]                |                               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:952:43
[INFO] [stderr]                |
[INFO] [stderr]            952 |                         while self.peek() == &Token::ColonColon {
[INFO] [stderr]                |                               ----------- ^^ ------------------ &Token
[INFO] [stderr]                |                               |
[INFO] [stderr]                |                               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:958:56
[INFO] [stderr]                |
[INFO] [stderr]            958 |                         let type_args = if self.peek() == &Token::Lt {
[INFO] [stderr]                |                                            ----------- ^^ ---------- &Token
[INFO] [stderr]                |                                            |
[INFO] [stderr]                |                                            &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:966:44
[INFO] [stderr]                |
[INFO] [stderr]            966 | ...                   if self.peek() == &Token::LParen {
[INFO] [stderr]                |                          ----------- ^^ -------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:984:51
[INFO] [stderr]                |
[INFO] [stderr]            984 | ...                   } else if self.peek() == &Token::LBrace
[INFO] [stderr]                |                                 ----------- ^^ -------------- &Token
[INFO] [stderr]                |                                 |
[INFO] [stderr]                |                                 &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:985:54
[INFO] [stderr]                |
[INFO] [stderr]            985 | ...                   && (self.peek_nth(1) == &Token::RBrace
[INFO] [stderr]                |                           ---------------- ^^ -------------- &Token
[INFO] [stderr]                |                           |
[INFO] [stderr]                |                           &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:986:110
[INFO] [stderr]                |
[INFO] [stderr]            986 | ...                   || (matches!(self.peek_nth(1), Token::Identifier(_)) && self.peek_nth(2) == &Token::Colon))
[INFO] [stderr]                |                                                                               ---------------- ^^ ------------- &Token
[INFO] [stderr]                |                                                                               |
[INFO] [stderr]                |                                                                               &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:990:48
[INFO] [stderr]                |
[INFO] [stderr]            990 | ...                   if self.peek() != &Token::RBrace {
[INFO] [stderr]                |                          ----------- ^^ -------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:996:56
[INFO] [stderr]                |
[INFO] [stderr]            996 | ...                   if self.peek() == &Token::Comma {
[INFO] [stderr]                |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]               --> compiler/src/parser/parse.rs:998:60
[INFO] [stderr]                |
[INFO] [stderr]            998 | ...                   if self.peek() == &Token::RBrace {
[INFO] [stderr]                |                          ----------- ^^ -------------- &Token
[INFO] [stderr]                |                          |
[INFO] [stderr]                |                          &Token
[INFO] [stderr]                |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 + #[derive(PartialEq)]
[INFO] [stderr]             21 | pub enum Token {
[INFO] [stderr]                |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1022:39
[INFO] [stderr]                 |
[INFO] [stderr]            1022 |                 } else if self.peek() == &Token::Lt {
[INFO] [stderr]                 |                           ----------- ^^ ---------- &Token
[INFO] [stderr]                 |                           |
[INFO] [stderr]                 |                           &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1037:39
[INFO] [stderr]                 |
[INFO] [stderr]            1037 |                 } else if self.peek() == &Token::LParen {
[INFO] [stderr]                 |                           ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                           |
[INFO] [stderr]                 |                           &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1044:39
[INFO] [stderr]                 |
[INFO] [stderr]            1044 |                 } else if self.peek() == &Token::LBrace
[INFO] [stderr]                 |                           ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                           |
[INFO] [stderr]                 |                           &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1045:42
[INFO] [stderr]                 |
[INFO] [stderr]            1045 |                     && (self.peek_nth(1) == &Token::RBrace
[INFO] [stderr]                 |                         ---------------- ^^ -------------- &Token
[INFO] [stderr]                 |                         |
[INFO] [stderr]                 |                         &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1046:98
[INFO] [stderr]                 |
[INFO] [stderr]            1046 |                         || (matches!(self.peek_nth(1), Token::Identifier(_)) && self.peek_nth(2) == &Token::Colon))
[INFO] [stderr]                 |                                                                                 ---------------- ^^ ------------- &Token
[INFO] [stderr]                 |                                                                                 |
[INFO] [stderr]                 |                                                                                 &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1050:36
[INFO] [stderr]                 |
[INFO] [stderr]            1050 |                     if self.peek() != &Token::RBrace {
[INFO] [stderr]                 |                        ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                        |
[INFO] [stderr]                 |                        &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1056:44
[INFO] [stderr]                 |
[INFO] [stderr]            1056 | ...                   if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                          |
[INFO] [stderr]                 |                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1058:48
[INFO] [stderr]                 |
[INFO] [stderr]            1058 | ...                   if self.peek() == &Token::RBrace {
[INFO] [stderr]                 |                          ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                          |
[INFO] [stderr]                 |                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1091:32
[INFO] [stderr]                 |
[INFO] [stderr]            1091 |                 if self.peek() != &Token::RBracket {
[INFO] [stderr]                 |                    ----------- ^^ ---------------- &Token
[INFO] [stderr]                 |                    |
[INFO] [stderr]                 |                    &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1095:40
[INFO] [stderr]                 |
[INFO] [stderr]            1095 |                         if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                            ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                            |
[INFO] [stderr]                 |                            &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1097:44
[INFO] [stderr]                 |
[INFO] [stderr]            1097 | ...                   if self.peek() == &Token::RBracket {
[INFO] [stderr]                 |                          ----------- ^^ ---------------- &Token
[INFO] [stderr]                 |                          |
[INFO] [stderr]                 |                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1131:79
[INFO] [stderr]                 |
[INFO] [stderr]            1131 |                         message: format!("expected expression, found '{:?}'", op),
[INFO] [stderr]                 |                                                                       ----    ^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                 |                                                                       |
[INFO] [stderr]                 |                                                                       required by this formatting parameter
[INFO] [stderr]                 |
[INFO] [stderr]                 = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(Debug)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1141:24
[INFO] [stderr]                 |
[INFO] [stderr]            1141 |             if next_op == &Token::Eof {
[INFO] [stderr]                 |                ------- ^^ ----------- &Token
[INFO] [stderr]                 |                |
[INFO] [stderr]                 |                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1149:29
[INFO] [stderr]                 |
[INFO] [stderr]            1149 |                 if op_token == Token::Question {
[INFO] [stderr]                 |                    -------- ^^ --------------- Token
[INFO] [stderr]                 |                    |
[INFO] [stderr]                 |                    Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1163:29
[INFO] [stderr]                 |
[INFO] [stderr]            1163 |                 if op_token == Token::Dot {
[INFO] [stderr]                 |                    -------- ^^ ---------- Token
[INFO] [stderr]                 |                    |
[INFO] [stderr]                 |                    Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1167:36
[INFO] [stderr]                 |
[INFO] [stderr]            1167 |                     if self.peek() == &Token::LParen {
[INFO] [stderr]                 |                        ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                        |
[INFO] [stderr]                 |                        &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1170:40
[INFO] [stderr]                 |
[INFO] [stderr]            1170 |                         if self.peek() != &Token::RParen {
[INFO] [stderr]                 |                            ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                            |
[INFO] [stderr]                 |                            &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1174:48
[INFO] [stderr]                 |
[INFO] [stderr]            1174 | ...                   if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                          ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                          |
[INFO] [stderr]                 |                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1195:36
[INFO] [stderr]                 |
[INFO] [stderr]            1195 |                 } else if op_token == Token::LBracket {
[INFO] [stderr]                 |                           -------- ^^ --------------- Token
[INFO] [stderr]                 |                           |
[INFO] [stderr]                 |                           Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0308]: mismatched types
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1269:19
[INFO] [stderr]                 |
[INFO] [stderr]            1269 |             Some((tok.clone(), *span))
[INFO] [stderr]                 |                   ^^^^^^^^^^^ expected `Token`, found `&Token`
[INFO] [stderr]                 |
[INFO] [stderr]            note: `Token` does not implement `Clone`, so `&Token` was cloned instead
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1269:19
[INFO] [stderr]                 |
[INFO] [stderr]            1269 |             Some((tok.clone(), *span))
[INFO] [stderr]                 |                   ^^^
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Clone)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(Clone)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1277:19
[INFO] [stderr]                 |
[INFO] [stderr]            1277 |         if actual == expected {
[INFO] [stderr]                 |            ------ ^^ -------- &Token
[INFO] [stderr]                 |            |
[INFO] [stderr]                 |            &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1284:67
[INFO] [stderr]                 |
[INFO] [stderr]            1284 |                 message: format!("expected '{:?}', found '{:?}'", expected, actual),
[INFO] [stderr]                 |                                             ----                  ^^^^^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stderr]                 |                                             |
[INFO] [stderr]                 |                                             required by this formatting parameter
[INFO] [stderr]                 |
[INFO] [stderr]                 = help: the trait `Debug` is not implemented for `Token`
[INFO] [stderr]                 = note: required for `&Token` to implement `Debug`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(Debug)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: `Token` doesn't implement `Debug`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1301:71
[INFO] [stderr]                 |
[INFO] [stderr]            1301 |                 message: format!("expected identifier, found '{:?}'", actual),
[INFO] [stderr]                 |                                                               ----    ^^^^^^ `Token` cannot be formatted using `{:?}` because it doesn't implement `Debug`
[INFO] [stdout] warning: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
[INFO] [stdout]    --> compiler/src/parser/parse.rs:690:34
[INFO] [stdout]     |
[INFO] [stdout] 690 |         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout]     |                                  ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/parser/parse.rs:690:16
[INFO] [stdout]     |
[INFO] [stdout] 690 |         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
[INFO] [stdout]     = warning: this changes meaning in Rust 2024
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
[INFO] [stdout]     = note: `--force-warn rust-2024-incompatible-pat` implied by `--force-warn rust-2024-compatibility`
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 690 -         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout] 690 +         if let Token::Identifier(name) = self.peek() {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                 |                                                               |
[INFO] [stdout] warning: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
[INFO] [stdout]    --> compiler/src/resolver.rs:319:29
[INFO] [stdout]     |
[INFO] [stdout] 319 |             TypeExpr::Named(ref mut name) => {
[INFO] [stdout]     |                             ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/resolver.rs:319:13
[INFO] [stdout]     |
[INFO] [stdout] 319 |             TypeExpr::Named(ref mut name) => {
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
[INFO] [stdout]     = warning: this changes meaning in Rust 2024
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 319 -             TypeExpr::Named(ref mut name) => {
[INFO] [stdout] 319 +             TypeExpr::Named(name) => {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                 |                                                               required by this formatting parameter
[INFO] [stdout] warning: cannot explicitly borrow within an implicitly-borrowing pattern in Rust 2024
[INFO] [stdout]    --> compiler/src/resolver.rs:696:29
[INFO] [stdout]     |
[INFO] [stdout] 696 |                 if let Some(ref mut v) = val {
[INFO] [stdout]     |                             ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/resolver.rs:696:24
[INFO] [stdout]     |
[INFO] [stdout] 696 |                 if let Some(ref mut v) = val {
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
[INFO] [stdout]     = warning: this changes meaning in Rust 2024
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/match-ergonomics.html>
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 696 -                 if let Some(ref mut v) = val {
[INFO] [stdout] 696 +                 if let Some(v) = val {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                 |
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, String, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: `--force-warn impl-trait-overcaptures` implied by `--force-warn rust-2024-compatibility`
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                 = help: the trait `Debug` is not implemented for `Token`
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, f64, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                 = note: required for `&Token` to implement `Debug`
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, bool, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(Debug)]`
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, String, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stdout] warning: `impl logos::internal::CallbackResult<'s, bool, Token>` will capture more lifetimes than possibly intended in edition 2024
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^^^^^
[INFO] [stdout]    |
[INFO] [stdout] note: specifically, this lifetime is in scope but not mentioned in the type's bounds
[INFO] [stdout]   --> compiler/src/lexer.rs:17:10
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |          ^
[INFO] [stdout]    = note: all lifetimes in scope will be captured by `impl Trait`s in edition 2024
[INFO] [stdout]    = warning: this changes meaning in Rust 2024
[INFO] [stdout]    = note: for more information, see <https://doc.rust-lang.org/edition-guide/rust-2024/rpit-lifetime-capture.html>
[INFO] [stdout]    = note: this warning originates in the derive macro `Logos` (in Nightly builds, run with -Z macro-backtrace for more info)
[INFO] [stdout] help: use the precise capturing `use<...>` syntax to make the captures explicit
[INFO] [stdout]    |
[INFO] [stdout] 17 | #[derive(Logos + use<'s>, Debug, Clone, PartialEq, Serialize, Deserialize)]
[INFO] [stdout]    |                +++++++++
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(Debug)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1313:28
[INFO] [stderr]                 |
[INFO] [stderr]            1313 |             if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                |
[INFO] [stderr]                 |                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1327:44
[INFO] [stderr]                 |
[INFO] [stderr]            1327 |         if parsed.is_some() && self.peek() == &Token::LParen {
[INFO] [stderr]                 |                                ----------- ^^ -------------- &Token
[INFO] [stderr]                 |                                |
[INFO] [stderr]                 |                                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `!=` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1338:24
[INFO] [stderr]                 |
[INFO] [stderr]            1338 |         if self.peek() != &Token::RParen {
[INFO] [stderr]                 |            ----------- ^^ -------------- &Token
[INFO] [stderr]                 |            |
[INFO] [stderr]                 |            &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1342:32
[INFO] [stderr]                 |
[INFO] [stderr]            1342 |                 if self.peek() == &Token::Comma {
[INFO] [stderr]                 |                    ----------- ^^ ------------- &Token
[INFO] [stderr]                 |                    |
[INFO] [stderr]                 |                    &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1356:21
[INFO] [stderr]                 |
[INFO] [stderr]            1356 |             if next == &Token::Semicolon {
[INFO] [stderr]                 |                ---- ^^ ----------------- &Token
[INFO] [stderr]                 |                |
[INFO] [stderr]                 |                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1360:21
[INFO] [stderr]                 |
[INFO] [stderr]            1360 |             if next == &Token::RBrace || next == &Token::Fn {
[INFO] [stderr]                 |                ---- ^^ -------------- &Token
[INFO] [stderr]                 |                |
[INFO] [stderr]                 |                &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0369]: binary operation `==` cannot be applied to type `&Token`
[INFO] [stderr]                --> compiler/src/parser/parse.rs:1360:47
[INFO] [stderr]                 |
[INFO] [stderr]            1360 |             if next == &Token::RBrace || next == &Token::Fn {
[INFO] [stderr]                 |                                          ---- ^^ ---------- &Token
[INFO] [stderr]                 |                                          |
[INFO] [stderr]                 |                                          &Token
[INFO] [stderr]                 |
[INFO] [stderr]            note: an implementation of `PartialEq` might be missing for `Token`
[INFO] [stderr]                --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 | pub enum Token {
[INFO] [stderr]                 | ^^^^^^^^^^^^^^ must implement `PartialEq`
[INFO] [stderr]            help: consider annotating `Token` with `#[derive(PartialEq)]`
[INFO] [stderr]                -->  compiler/src/lexer.rs:20:1
[INFO] [stderr]                 |
[INFO] [stderr]              20 + #[derive(PartialEq)]
[INFO] [stderr]              21 | pub enum Token {
[INFO] [stderr]                 |
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]              --> compiler/src/resolver.rs:63:25
[INFO] [stderr]               |
[INFO] [stderr]            63 |             let lexer = Lexer::new(&source);
[INFO] [stderr]               |                         ^^^^^ unsatisfied trait bound
[INFO] [stderr]               |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]              --> compiler/src/resolver.rs:63:25
[INFO] [stderr]               |
[INFO] [stderr]            63 |             let lexer = Lexer::new(&source);
[INFO] [stderr]               |                         ^^^^^^^^^^^^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]               |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied in `lexer::Lexer<'_>`
[INFO] [stderr]               --> compiler/src/resolver.rs:63:17
[INFO] [stderr]                |
[INFO] [stderr]             63 |             let lexer = Lexer::new(&source);
[INFO] [stderr]                |                 ^^^^^ unsatisfied trait bound
[INFO] [stderr]                |
[INFO] [stderr]            help: within `lexer::Lexer<'_>`, the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]               --> compiler/src/lexer.rs:20:1
[INFO] [stderr]                |
[INFO] [stderr]             20 | pub enum Token {
[INFO] [stderr]                | ^^^^^^^^^^^^^^
[INFO] [stderr]            note: required because it appears within the type `lexer::Lexer<'_>`
[INFO] [stderr]               --> compiler/src/lexer.rs:338:12
[INFO] [stderr]                |
[INFO] [stderr]            338 | pub struct Lexer<'src> {
[INFO] [stderr]                |            ^^^^^
[INFO] [stderr]                = note: all local variables must have a statically known size
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error[E0277]: the trait bound `Token: Logos<'_>` is not satisfied
[INFO] [stderr]              --> compiler/src/resolver.rs:64:46
[INFO] [stderr]               |
[INFO] [stderr]            64 |             let (tokens, lex_errors) = lexer.tokenize();
[INFO] [stderr]               |                                              ^^^^^^^^ unsatisfied trait bound
[INFO] [stderr]               |
[INFO] [stderr]            help: the trait `Logos<'_>` is not implemented for `Token`
[INFO] [stderr]              --> compiler/src/lexer.rs:20:1
[INFO] [stderr]               |
[INFO] [stderr]            20 | pub enum Token {
[INFO] [stderr]               | ^^^^^^^^^^^^^^
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            error: aborting due to 220 previous errors
[INFO] [stderr]            
[INFO] [stderr]            
[INFO] [stderr]            Some errors have detailed explanations: E0277, E0308, E0369, E0599.
[INFO] [stderr]            
[INFO] [stderr]            For more information about an error, try `rustc --explain E0277`.
[INFO] [stderr] help: to report this as a bug, open an issue at https://github.com/rust-lang/rust/issues, quoting the full output of this command
[INFO] [stderr] help: to possibly apply more fixes, pass in the `--broken-code` flag
[INFO] [stderr] note: original diagnostics will follow:
[INFO] [stderr]    Migrating compiler/tests/lexer_snapshot.rs from 2021 edition to 2024
[INFO] [stderr]        Fixed compiler/tests/lexer_snapshot.rs (1 fix)
[INFO] [stderr]    Migrating compiler/tests/parser_snapshot.rs from 2021 edition to 2024
[INFO] [stderr]    Migrating compiler/src/main.rs from 2021 edition to 2024
[INFO] [stderr]     Finished `dev` profile [unoptimized + debuginfo] target(s) in 34.15s
[INFO] [stderr] crater-edition-check: atlas v0.1.0 (/opt/rustwide/workdir/compiler) updating edition from 2021 to 2024
[INFO] [stderr]     Checking atlas v0.1.0 (/opt/rustwide/workdir/compiler)
[INFO] [stdout] error: cannot explicitly borrow within an implicitly-borrowing pattern
[INFO] [stdout]    --> compiler/src/parser/parse.rs:690:34
[INFO] [stdout]     |
[INFO] [stdout] 690 |         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout]     |                                  ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/parser/parse.rs:690:16
[INFO] [stdout]     |
[INFO] [stdout] 690 |         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 690 -         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout] 690 +         if let Token::Identifier(name) = self.peek() {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot explicitly borrow within an implicitly-borrowing pattern
[INFO] [stdout]    --> compiler/src/resolver.rs:319:29
[INFO] [stdout]     |
[INFO] [stdout] 319 |             TypeExpr::Named(ref mut name) => {
[INFO] [stdout]     |                             ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/resolver.rs:319:13
[INFO] [stdout]     |
[INFO] [stdout] 319 |             TypeExpr::Named(ref mut name) => {
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 319 -             TypeExpr::Named(ref mut name) => {
[INFO] [stdout] 319 +             TypeExpr::Named(name) => {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot explicitly borrow within an implicitly-borrowing pattern
[INFO] [stdout]    --> compiler/src/resolver.rs:696:29
[INFO] [stdout]     |
[INFO] [stdout] 696 |                 if let Some(ref mut v) = val {
[INFO] [stdout]     |                             ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/resolver.rs:696:24
[INFO] [stdout]     |
[INFO] [stdout] 696 |                 if let Some(ref mut v) = val {
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 696 -                 if let Some(ref mut v) = val {
[INFO] [stdout] 696 +                 if let Some(v) = val {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot explicitly borrow within an implicitly-borrowing pattern
[INFO] [stdout]    --> compiler/src/parser/parse.rs:690:34
[INFO] [stdout]     |
[INFO] [stdout] 690 |         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout]     |                                  ^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/parser/parse.rs:690:16
[INFO] [stdout]     |
[INFO] [stdout] 690 |         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout]     |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&_`
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 690 -         if let Token::Identifier(ref name) = self.peek() {
[INFO] [stdout] 690 +         if let Token::Identifier(name) = self.peek() {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot explicitly borrow within an implicitly-borrowing pattern
[INFO] [stdout]    --> compiler/src/resolver.rs:319:29
[INFO] [stdout]     |
[INFO] [stdout] 319 |             TypeExpr::Named(ref mut name) => {
[INFO] [stdout]     |                             ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/resolver.rs:319:13
[INFO] [stdout]     |
[INFO] [stdout] 319 |             TypeExpr::Named(ref mut name) => {
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 319 -             TypeExpr::Named(ref mut name) => {
[INFO] [stdout] 319 +             TypeExpr::Named(name) => {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: cannot explicitly borrow within an implicitly-borrowing pattern
[INFO] [stdout]    --> compiler/src/resolver.rs:696:29
[INFO] [stdout]     |
[INFO] [stdout] 696 |                 if let Some(ref mut v) = val {
[INFO] [stdout]     |                             ^^^^^^^ explicit `ref` binding modifier not allowed when implicitly borrowing
[INFO] [stdout]     |
[INFO] [stdout]     = note: for more information, see <https://doc.rust-lang.org/reference/patterns.html#binding-modes>
[INFO] [stdout] note: matching on a reference type with a non-reference pattern implicitly borrows the contents
[INFO] [stdout]    --> compiler/src/resolver.rs:696:24
[INFO] [stdout]     |
[INFO] [stdout] 696 |                 if let Some(ref mut v) = val {
[INFO] [stdout]     |                        ^^^^^^^^^^^^^^^ this non-reference pattern matches on a reference type `&mut _`
[INFO] [stdout] help: remove the unnecessary binding modifier
[INFO] [stdout]     |
[INFO] [stdout] 696 -                 if let Some(ref mut v) = val {
[INFO] [stdout] 696 +                 if let Some(v) = val {
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `atlas` (lib) due to 3 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] error: could not compile `atlas` (lib test) due to 3 previous errors
[INFO] running `Command { std: "docker" "inspect" "def61b1433e341a7211dbe7bf0a20537bc57c529e2d3019f9b6bfedb7a602444", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "def61b1433e341a7211dbe7bf0a20537bc57c529e2d3019f9b6bfedb7a602444", kill_on_drop: false }`
[INFO] [stdout] def61b1433e341a7211dbe7bf0a20537bc57c529e2d3019f9b6bfedb7a602444
